package com.wicket.okrpbff.biz.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.wicket.okrapp.common.baseinfo.BaseInfoHolder;
import com.wicket.okrcomponent.common.util.CommonFunctionHelper;
import com.wicket.okrpbff.biz.service.SystemTestDomainService;
import com.wicket.okrpbff.biz.service.nb.NbSystemTestDomain;
import com.wicket.okrpbff.common.baseinfo.BaseInfoDO;
import com.wicket.okrpbff.common.ro.OkrResult;
import com.wicket.okrpbff.biz.service.dto.req.*;
import com.wicket.okrpbff.biz.service.dto.res.*;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import com.wicket.okrpbff.common.ro.OkrResult;
import com.wicket.okrpbff.common.util.RedisUtil;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import com.wicket.okrapp.integration.FwAppSystemTestDomainClient;
import com.wicket.okrapp.integration.dto.AutoBuildTopAndMidAndGrassRespDto;
import com.wicket.okrapp.integration.dto.AutoBuildTopAndMidAndGrassReqDto;
import com.wicket.okrpbff.common.exception.Assert;
import com.wicket.okrapp.integration.dto.DeleteReportTaskRelatedDataComRespDto;
import com.wicket.okrapp.integration.dto.DeleteReportTaskRelatedDataComReqDto;
import com.wicket.okrapp.integration.dto.DeleteAddEvaTempDataComRespDto;
import com.wicket.okrapp.integration.dto.DeleteAddEvaTempDataComReqDto;
import com.wicket.okrapp.integration.dto.StructureDepObjMisStaRespDto;
import com.wicket.okrapp.integration.dto.StructureDepObjMisStaReqDto;
import com.wicket.okrapp.integration.dto.BatchResetTopMidBatchDataRespDto;
import com.wicket.okrapp.integration.dto.BatchResetTopMidBatchDataReqDto;
import com.wicket.okrapp.integration.dto.AutoBuildSingleTargetObjectiveRespDto;
import com.wicket.okrapp.integration.dto.AutoBuildSingleTargetObjectiveReqDto;
import com.wicket.okrapp.integration.dto.AutoDeleteAddEvaTempDataComRespDto;
import com.wicket.okrapp.integration.dto.AutoDeleteAddEvaTempDataComReqDto;
import com.wicket.okrapp.integration.dto.QueryTopMidBatchDataDetailRespDto;
import com.wicket.okrapp.integration.dto.QueryTopMidBatchDataDetailReqDto;
import com.wicket.okrapp.integration.dto.AutoBuildSingleEvaObjTarCycRespDto;
import com.wicket.okrapp.integration.dto.AutoBuildSingleEvaObjTarCycReqDto;
import com.wicket.okrapp.integration.dto.AutoDeleteSingleTargetObjectiveRespDto;
import com.wicket.okrapp.integration.dto.AutoDeleteSingleTargetObjectiveReqDto;
import com.wicket.okrapp.integration.dto.DeleteSingleEvaObjTarCycComRespDto;
import com.wicket.okrapp.integration.dto.DeleteSingleEvaObjTarCycComReqDto;
import com.wicket.okrapp.integration.dto.AutoBuildAssistNnodeStatusEtcTestRespDto;
import com.wicket.okrapp.integration.dto.AutoBuildAssistNnodeStatusEtcTestReqDto;
import com.wicket.okrapp.integration.dto.AutoBuildStatusCheckItemTestRespDto;
import com.wicket.okrapp.integration.dto.AutoBuildStatusCheckItemTestReqDto;
import com.wicket.okrapp.integration.dto.AutoBuildAssistCheckPanelTestRespDto;
import com.wicket.okrapp.integration.dto.AutoBuildAssistCheckPanelTestReqDto;
import com.wicket.okrapp.integration.dto.AutoBuildSingleTargetCategoryRespDto;
import com.wicket.okrapp.integration.dto.AutoBuildSingleTargetCategoryReqDto;
import com.wicket.okrapp.integration.dto.AutoDeleteSingleTargetCategoryRespDto;
import com.wicket.okrapp.integration.dto.AutoDeleteSingleTargetCategoryReqDto;
import com.wicket.okrapp.integration.dto.QuerySingleTargetDetailRespDto;
import com.wicket.okrapp.integration.dto.QuerySingleTargetDetailReqDto;
import com.wicket.okrframework.integration.FwBaseDivineDataClient;
import com.wicket.okrframework.integration.dto.PutPublicFieldCacheComRespDto;
import com.wicket.okrframework.integration.dto.PutPublicFieldCacheComReqDto;
import com.wicket.okrapp.integration.dto.AutoBuildEvaObjTarCycStaDataComRespDto;
import com.wicket.okrapp.integration.dto.AutoBuildEvaObjTarCycStaDataComReqDto;
import com.wicket.okrapp.integration.dto.AutoBuildSingleVirtualOrgMemberRespDto;
import com.wicket.okrapp.integration.dto.AutoBuildSingleVirtualOrgMemberReqDto;
import com.wicket.okrcalc.integration.FwCalcSystemTestDomainClient;
import com.wicket.okrcalc.integration.dto.UpdateSingleEvaObjTarCycStaDataRespDto;
import com.wicket.okrcalc.integration.dto.UpdateSingleEvaObjTarCycStaDataReqDto;
import com.wicket.okrapp.integration.dto.BuildAssistNnodeStatusTestRespDto;
import com.wicket.okrapp.integration.dto.BuildAssistNnodeStatusTestReqDto;
import com.wicket.okrapp.integration.dto.BuildSingleBatchComRespDto;
import com.wicket.okrapp.integration.dto.BuildSingleBatchComReqDto;
import com.wicket.okrapp.integration.dto.UpdateEvaTempTypeEtcRespDto;
import com.wicket.okrapp.integration.dto.UpdateEvaTempTypeEtcReqDto;
import com.wicket.okrframework.integration.FwBaseSystemTestDomainClient;
import com.wicket.okrframework.integration.dto.DeleteSpaceTestDataRespDto;
import com.wicket.okrframework.integration.dto.DeleteSpaceTestDataReqDto;
import com.wicket.okrapp.integration.dto.AutoDeleteSingleTargetCategoryComRespDto;
import com.wicket.okrapp.integration.dto.AutoDeleteSingleTargetCategoryComReqDto;
import com.wicket.okrapp.integration.dto.DeleteDeptObjTreeTestDataComRespDto;
import com.wicket.okrapp.integration.dto.DeleteDeptObjTreeTestDataComReqDto;
import com.wicket.okrapp.integration.dto.BatchDeleteDeptTargetContentTestComRespDto;
import com.wicket.okrapp.integration.dto.BatchDeleteDeptTargetContentTestComReqDto;
import com.wicket.okrapp.integration.dto.ImplementUpdateStatusCheckItemDataRespDto;
import com.wicket.okrapp.integration.dto.ImplementUpdateStatusCheckItemDataReqDto;
import com.wicket.okrapp.integration.dto.ImplementUpdateStatusCheckItemDataComRespDto;
import com.wicket.okrapp.integration.dto.ImplementUpdateStatusCheckItemDataComReqDto;
import com.wicket.okrapp.integration.dto.ImplementUpdateAssistCheckPanelTestComRespDto;
import com.wicket.okrapp.integration.dto.ImplementUpdateAssistCheckPanelTestComReqDto;
import com.wicket.okrapp.integration.dto.ImplementUpdateAssistNnodeStatusTestComRespDto;
import com.wicket.okrapp.integration.dto.ImplementUpdateAssistNnodeStatusTestComReqDto;
import com.wicket.okrapp.integration.dto.ImplementCorrectionTempParentNodeStatusTestRespDto;
import com.wicket.okrapp.integration.dto.ImplementCorrectionTempParentNodeStatusTestReqDto;
import com.wicket.okrapp.integration.dto.ImplementTargetContCheckItemThreeTestComRespDto;
import com.wicket.okrapp.integration.dto.ImplementTargetContCheckItemThreeTestComReqDto;
import com.wicket.okrapp.integration.dto.ImplementCleanTargetContRubbishDataComRespDto;
import com.wicket.okrapp.integration.dto.ImplementCleanTargetContRubbishDataComReqDto;
import com.wicket.okrapp.integration.dto.ImplementObjtivePrincipalAnalyseComRespDto;
import com.wicket.okrapp.integration.dto.ImplementObjtivePrincipalAnalyseComReqDto;
import com.wicket.okrapp.integration.dto.ImplementLoopInitializeDeptOkrRootNodeCheckitemStateComRespDto;
import com.wicket.okrapp.integration.dto.ImplementLoopInitializeDeptOkrRootNodeCheckitemStateComReqDto;
import com.wicket.okrapp.integration.dto.ImplementCompensateObjtiveOtherTreeNodeComRespDto;
import com.wicket.okrapp.integration.dto.ImplementCompensateObjtiveOtherTreeNodeComReqDto;
import com.wicket.okrapp.integration.dto.ImplementDeptTargetTaskLeafNodeStateComRespDto;
import com.wicket.okrapp.integration.dto.ImplementDeptTargetTaskLeafNodeStateComReqDto;
import com.wicket.okrapp.integration.dto.ImplementOkrTreeCheckItemStateEtcInitializeEtcTestComRespDto;
import com.wicket.okrapp.integration.dto.ImplementOkrTreeCheckItemStateEtcInitializeEtcTestComReqDto;
import com.wicket.okrapp.integration.dto.ImplementLoopInitializeOkrTreeCheckitemStateEtcComRespDto;
import com.wicket.okrapp.integration.dto.ImplementLoopInitializeOkrTreeCheckitemStateEtcComReqDto;
import com.wicket.okrapp.integration.dto.ImplementAmendTempExeCycleAndReportDispatchEtcTestRespDto;
import com.wicket.okrapp.integration.dto.ImplementAmendTempExeCycleAndReportDispatchEtcTestReqDto;

/**
 * @author ：
 * @date ：
 *
 *
 * @version 1.0
 */
@Service
public class SystemTestDomainServiceImpl implements SystemTestDomainService {

    @Resource
    private RedisUtil redisUtil;
@Resource
  FwAppSystemTestDomainClient fwAppSystemTestDomainClient;
@Resource
  FwBaseDivineDataClient fwBaseDivineDataClient;
@Resource
NbSystemTestDomain nbSystemTestDomain;
@Resource
  FwCalcSystemTestDomainClient fwCalcSystemTestDomainClient;
@Resource
  FwBaseSystemTestDomainClient fwBaseSystemTestDomainClient;
/**
   * B3一键构造高中基层验证数据(管理)[4269]
   * gen by moon at 9/12/2022, 10:16:11 PM
   */
    @Trace(operationName = "B3一键构造高中基层验证数据(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffAutoBuildTopAndMidAndGrassRespDto autoBuildTopAndMidAndGrass(BffAutoBuildTopAndMidAndGrassReqDto reqDto){
      
       
       //步骤0: D3-一键构造高中基层验证数据 - autoBuildTopAndMidAndGrass
     AutoBuildTopAndMidAndGrassRespDto autoBuildTopAndMidAndGrassRespDto = null;
    AutoBuildTopAndMidAndGrassReqDto autoBuildTopAndMidAndGrassReqDto=new AutoBuildTopAndMidAndGrassReqDto();
  if(reqDto!=null){
      autoBuildTopAndMidAndGrassReqDto.setPeriodicModeTypeCode(reqDto.getPeriodicModeTypeCode());//sourceId:284987_1
autoBuildTopAndMidAndGrassReqDto.setIsFirst(reqDto.getIsFirst());//sourceId:269542_1
autoBuildTopAndMidAndGrassReqDto.setTaskStatus(reqDto.getTaskStatus());//sourceId:304746_1
autoBuildTopAndMidAndGrassReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//sourceId:269543_1
autoBuildTopAndMidAndGrassReqDto.setArchivngType(reqDto.getArchivngType());//sourceId:272991_1
autoBuildTopAndMidAndGrassReqDto.setCreateInductionId(reqDto.getCreateInductionId());//sourceId:269531_1
autoBuildTopAndMidAndGrassReqDto.setSpaceId(reqDto.getSpaceId());//sourceId:269532_1
autoBuildTopAndMidAndGrassReqDto.setAppId(reqDto.getAppId());//sourceId:269533_1
    }
  
    /*D3-一键构造高中基层验证数据[4238]   */
    Assert.isNull(autoBuildTopAndMidAndGrassReqDto.getPeriodicModeTypeCode(),"B3一键构造高中基层验证数据(管理)-D3-一键构造高中基层验证数据-周期模式类型编码不能为空",false);
      autoBuildTopAndMidAndGrassRespDto = fwAppSystemTestDomainClient.autoBuildTopAndMidAndGrass(autoBuildTopAndMidAndGrassReqDto).getData();
      
      
      
    
BffAutoBuildTopAndMidAndGrassRespDto retData = new BffAutoBuildTopAndMidAndGrassRespDto();
  
  

  
  
return retData;
  }
/**
   * B3-删除汇报任务相关数据（系统测试）[4312]
   * gen by moon at 8/31/2022, 5:42:20 PM
   */
    @Trace(operationName = "B3-删除汇报任务相关数据（系统测试）")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffDeleteReportTaskRelatedDataRespDto deleteReportTaskRelatedData(BffDeleteReportTaskRelatedDataReqDto reqDto){
      
       
       //步骤0: D3-删除汇报任务相关数据(公共) - deleteReportTaskRelatedDataCom
     DeleteReportTaskRelatedDataComRespDto deleteReportTaskRelatedDataComRespDto = null;
    DeleteReportTaskRelatedDataComReqDto deleteReportTaskRelatedDataComReqDto=new DeleteReportTaskRelatedDataComReqDto();
  if(reqDto!=null){
      deleteReportTaskRelatedDataComReqDto.setTaskId(reqDto.getTaskId());//sourceId:284974_1
    }
  
    /*D3-删除汇报任务相关数据(公共)[4211]   */
    Assert.isNull(deleteReportTaskRelatedDataComReqDto.getTaskId(),"B3-删除汇报任务相关数据（系统测试）-D3-删除汇报任务相关数据(公共)-任务ID不能为空",false);
      deleteReportTaskRelatedDataComRespDto = fwAppSystemTestDomainClient.deleteReportTaskRelatedDataCom(deleteReportTaskRelatedDataComReqDto).getData();
      
      
    
BffDeleteReportTaskRelatedDataRespDto retData = new BffDeleteReportTaskRelatedDataRespDto();
  
  

  
  
return retData;
  }
/**
   * B3-一键删除评价模板数据[4311]
   * gen by moon at 6/11/2023, 6:51:27 AM
   */
    @Trace(operationName = "B3-一键删除评价模板数据")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffDeleteAddEvaTempDataRespDto deleteAddEvaTempData(BffDeleteAddEvaTempDataReqDto reqDto){
      
       
       //步骤0: D3-一键删除评价模板验证数据(公共) - autoDeleteAddEvaTempDataCom
     AutoDeleteAddEvaTempDataComRespDto autoDeleteAddEvaTempDataComRespDto = null;
    AutoDeleteAddEvaTempDataComReqDto autoDeleteAddEvaTempDataComReqDto=new AutoDeleteAddEvaTempDataComReqDto();
  if(reqDto!=null){
      autoDeleteAddEvaTempDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1030494_1
autoDeleteAddEvaTempDataComReqDto.setCreateInductionId(reqDto.getCreateInductionId());//SimpleFieldAssign//sourceId:1032577_1
autoDeleteAddEvaTempDataComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1032578_1
autoDeleteAddEvaTempDataComReqDto.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1032579_1
    }
  
    /*D3-一键删除评价模板验证数据(公共)[4207]   */
    Assert.isNull(autoDeleteAddEvaTempDataComReqDto.getEvaluationTemplateId(),"B3-一键删除评价模板数据-D3-一键删除评价模板验证数据(公共)-评价模板ID不能为空",false);
Assert.isNull(autoDeleteAddEvaTempDataComReqDto.getCreateInductionId(),"B3-一键删除评价模板数据-D3-一键删除评价模板验证数据(公共)-创建人就职记录ID 不能为空",false);
Assert.isNull(autoDeleteAddEvaTempDataComReqDto.getSpaceId(),"B3-一键删除评价模板数据-D3-一键删除评价模板验证数据(公共)-创建于空间ID不能为空",false);
Assert.isNull(autoDeleteAddEvaTempDataComReqDto.getAppId(),"B3-一键删除评价模板数据-D3-一键删除评价模板验证数据(公共)-创建于联盟应用ID不能为空",false);
      autoDeleteAddEvaTempDataComRespDto = fwAppSystemTestDomainClient.autoDeleteAddEvaTempDataCom(autoDeleteAddEvaTempDataComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
    
BffDeleteAddEvaTempDataRespDto retData = new BffDeleteAddEvaTempDataRespDto();
  
  

  
  
return retData;
  }
/**
   * B3一键删除汇报任务相关验证数据[4312]
   * gen by moon at 9/3/2022, 7:38:52 PM
   */
    @Trace(operationName = "B3一键删除汇报任务相关验证数据")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffAutoDeleteReportTaskRelatedDataRespDto autoDeleteReportTaskRelatedData(BffAutoDeleteReportTaskRelatedDataReqDto reqDto){
      
       
       //步骤0: D3-删除汇报任务相关数据(公共) - deleteReportTaskRelatedDataCom
     DeleteReportTaskRelatedDataComRespDto deleteReportTaskRelatedDataComRespDto = null;
    DeleteReportTaskRelatedDataComReqDto deleteReportTaskRelatedDataComReqDto=new DeleteReportTaskRelatedDataComReqDto();
  if(reqDto!=null){
      deleteReportTaskRelatedDataComReqDto.setTaskId(reqDto.getTaskId());//sourceId:284974_1
    }
  
    /*D3-删除汇报任务相关数据(公共)[4211]   */
    Assert.isNull(deleteReportTaskRelatedDataComReqDto.getTaskId(),"B3一键删除汇报任务相关验证数据-D3-删除汇报任务相关数据(公共)-任务ID不能为空",false);
      deleteReportTaskRelatedDataComRespDto = fwAppSystemTestDomainClient.deleteReportTaskRelatedDataCom(deleteReportTaskRelatedDataComReqDto).getData();
      
      
      
    
BffAutoDeleteReportTaskRelatedDataRespDto retData = new BffAutoDeleteReportTaskRelatedDataRespDto();
  
  

  
  
return retData;
  }
/**
   * B3一键构造部门目标任务书验证数据[4378]
   * gen by moon at 9/12/2022, 10:16:13 PM
   */
    @Trace(operationName = "B3一键构造部门目标任务书验证数据")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffAutoBuildDepObjMisStaRespDto autoBuildDepObjMisSta(BffAutoBuildDepObjMisStaReqDto reqDto){
      
       
       //步骤0: D3-构建部门目标任务书 - structureDepObjMisSta
     StructureDepObjMisStaRespDto structureDepObjMisStaRespDto = null;
    StructureDepObjMisStaReqDto structureDepObjMisStaReqDto=new StructureDepObjMisStaReqDto();
  structureDepObjMisStaReqDto.setDeptId("113643928233975808");//CUSTOM_CONVENTION//sourceId:306219_1
structureDepObjMisStaReqDto.setEvaluationObjectId("126376802465103872");//CUSTOM_CONVENTION//sourceId:305536_1
structureDepObjMisStaReqDto.setWeightValue(Double.valueOf("100"));//CUSTOM_CONVENTION//sourceId:305540_1
structureDepObjMisStaReqDto.setWeightScore(Double.valueOf("100"));//CUSTOM_CONVENTION//sourceId:305541_1
if(reqDto!=null){
      structureDepObjMisStaReqDto.setTargetId(reqDto.getTargetId());//sourceId:305537_1
structureDepObjMisStaReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//sourceId:305539_1
    }
  
    /*D3-构建部门目标任务书[4377]   */
    Assert.isNull(structureDepObjMisStaReqDto.getTargetId(),"B3一键构造部门目标任务书验证数据-D3-构建部门目标任务书-目标ID不能为空",false);
Assert.isNull(structureDepObjMisStaReqDto.getSubjectLifeCycle(),"B3一键构造部门目标任务书验证数据-D3-构建部门目标任务书-主体生命周期不能为空",false);
Assert.isNull(structureDepObjMisStaReqDto.getDeptId(),"B3一键构造部门目标任务书验证数据-D3-构建部门目标任务书-部门ID不能为空",false);
Assert.isNull(structureDepObjMisStaReqDto.getEvaluationObjectId(),"B3一键构造部门目标任务书验证数据-D3-构建部门目标任务书-评价对象ID不能为空",false);
Assert.isNull(structureDepObjMisStaReqDto.getWeightValue(),"B3一键构造部门目标任务书验证数据-D3-构建部门目标任务书-权重不能为空",false);
Assert.isNull(structureDepObjMisStaReqDto.getWeightScore(),"B3一键构造部门目标任务书验证数据-D3-构建部门目标任务书-权重分值不能为空",false);
      structureDepObjMisStaRespDto = fwAppSystemTestDomainClient.structureDepObjMisSta(structureDepObjMisStaReqDto).getData();
      
      
      
    
BffAutoBuildDepObjMisStaRespDto retData = new BffAutoBuildDepObjMisStaRespDto();
  
  

  
  
return retData;
  }
/**
   * B3一键重置高中基批次状态数据(管理)[4396]
   * gen by moon at 9/14/2022, 10:18:54 PM
   */
    @Trace(operationName = "B3一键重置高中基批次状态数据(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffBatchResetTopMidBatchDataRespDto batchResetTopMidBatchData(BffBatchResetTopMidBatchDataReqDto reqDto){
      
       
       QueryTopMidBatchDataDetailRespDto queryTopMidBatchDataDetailRespDto_1 =null;
//步骤0: D3一键重置高中基批次状态数据 - batchResetTopMidBatchData
     BatchResetTopMidBatchDataRespDto batchResetTopMidBatchDataRespDto = null;
    BatchResetTopMidBatchDataReqDto batchResetTopMidBatchDataReqDto=new BatchResetTopMidBatchDataReqDto();
  if(reqDto!=null){
      batchResetTopMidBatchDataReqDto.setStatusCheckItemId(reqDto.getStatusCheckItemId());//sourceId:307105_1
batchResetTopMidBatchDataReqDto.setNewBatchCode(reqDto.getNewBatchCode());//sourceId:323534_1
batchResetTopMidBatchDataReqDto.setHistoryBatchCode(reqDto.getHistoryBatchCode());//sourceId:323535_1
batchResetTopMidBatchDataReqDto.setIsFirst(reqDto.getIsFirst());//sourceId:307098_1
batchResetTopMidBatchDataReqDto.setEvaTempStartMgtType(reqDto.getEvaTempStartMgtType());//sourceId:307097_1
batchResetTopMidBatchDataReqDto.setBatchSetId(reqDto.getBatchSetId());//sourceId:307101_1
batchResetTopMidBatchDataReqDto.setBatchSetObjectType(reqDto.getBatchSetObjectType());//sourceId:307102_1
batchResetTopMidBatchDataReqDto.setCurrentManageObjectType(reqDto.getCurrentManageObjectType());//sourceId:307104_1
batchResetTopMidBatchDataReqDto.setIsUnifiedMgt(reqDto.getIsUnifiedMgt());//sourceId:307103_1
    }
  
    /*D3一键重置高中基批次状态数据[4388]   */
    Assert.isNull(batchResetTopMidBatchDataReqDto.getStatusCheckItemId(),"B3一键重置高中基批次状态数据(管理)-D3一键重置高中基批次状态数据-状态校验项ID不能为空",false);
Assert.isNull(batchResetTopMidBatchDataReqDto.getNewBatchCode(),"B3一键重置高中基批次状态数据(管理)-D3一键重置高中基批次状态数据-最新批次标识不能为空",false);
Assert.isNull(batchResetTopMidBatchDataReqDto.getIsFirst(),"B3一键重置高中基批次状态数据(管理)-D3一键重置高中基批次状态数据-是否首次批次不能为空",false);
Assert.isNull(batchResetTopMidBatchDataReqDto.getEvaTempStartMgtType(),"B3一键重置高中基批次状态数据(管理)-D3一键重置高中基批次状态数据-评价模板开始管理类型不能为空",false);
Assert.isNull(batchResetTopMidBatchDataReqDto.getBatchSetId(),"B3一键重置高中基批次状态数据(管理)-D3一键重置高中基批次状态数据-批次设置对象ID不能为空",false);
Assert.isNull(batchResetTopMidBatchDataReqDto.getBatchSetObjectType(),"B3一键重置高中基批次状态数据(管理)-D3一键重置高中基批次状态数据-批次设置对象类型不能为空",false);
Assert.isNull(batchResetTopMidBatchDataReqDto.getIsUnifiedMgt(),"B3一键重置高中基批次状态数据(管理)-D3一键重置高中基批次状态数据-是否统一管理不能为空",false);
      batchResetTopMidBatchDataRespDto = fwAppSystemTestDomainClient.batchResetTopMidBatchData(batchResetTopMidBatchDataReqDto).getData();
      
      
      
    
//步骤1: D3-3查询高中基批次状态数据详情 - queryTopMidBatchDataDetail
     QueryTopMidBatchDataDetailRespDto queryTopMidBatchDataDetailRespDto = null;
    QueryTopMidBatchDataDetailReqDto queryTopMidBatchDataDetailReqDto=new QueryTopMidBatchDataDetailReqDto();
  if(reqDto!=null){
      queryTopMidBatchDataDetailReqDto.setNewBatchCode(reqDto.getNewBatchCode());//sourceId:323508_1
queryTopMidBatchDataDetailReqDto.setHistoryBatchCode(reqDto.getHistoryBatchCode());//sourceId:323509_1
queryTopMidBatchDataDetailReqDto.setStatusCheckItemId(reqDto.getStatusCheckItemId());//sourceId:310338_1
queryTopMidBatchDataDetailReqDto.setBatchSetId(reqDto.getBatchSetId());//sourceId:310339_1
queryTopMidBatchDataDetailReqDto.setBatchSetObjectType(reqDto.getBatchSetObjectType());//sourceId:310340_1
    }
  
    /*D3-3查询高中基批次状态数据详情[4408]   */
    Assert.isNull(queryTopMidBatchDataDetailReqDto.getNewBatchCode(),"B3一键重置高中基批次状态数据(管理)-D3-3查询高中基批次状态数据详情-最新批次标识不能为空",false);
Assert.isNull(queryTopMidBatchDataDetailReqDto.getStatusCheckItemId(),"B3一键重置高中基批次状态数据(管理)-D3-3查询高中基批次状态数据详情-状态校验项ID不能为空",false);
Assert.isNull(queryTopMidBatchDataDetailReqDto.getBatchSetId(),"B3一键重置高中基批次状态数据(管理)-D3-3查询高中基批次状态数据详情-批次设置对象ID不能为空",false);
Assert.isNull(queryTopMidBatchDataDetailReqDto.getBatchSetObjectType(),"B3一键重置高中基批次状态数据(管理)-D3-3查询高中基批次状态数据详情-批次设置对象类型不能为空",false);
      queryTopMidBatchDataDetailRespDto = fwAppSystemTestDomainClient.queryTopMidBatchDataDetail(queryTopMidBatchDataDetailReqDto).getData();
      
      
      queryTopMidBatchDataDetailRespDto_1 = queryTopMidBatchDataDetailRespDto;
    
BffBatchResetTopMidBatchDataRespDto retData = new BffBatchResetTopMidBatchDataRespDto();
  if(queryTopMidBatchDataDetailRespDto_1!=null){
      retData.setNewBatchId(queryTopMidBatchDataDetailRespDto_1.getNewBatchId());//sourceId:323514_1
retData.setNewBatchCode(queryTopMidBatchDataDetailRespDto_1.getNewBatchCode());//sourceId:329212_1
retData.setNewIsFirst(queryTopMidBatchDataDetailRespDto_1.getNewIsFirst());//sourceId:310380_1
retData.setNewIsNewbatch(queryTopMidBatchDataDetailRespDto_1.getNewIsNewbatch());//sourceId:310381_1
retData.setNewSubjectLifeCycle(queryTopMidBatchDataDetailRespDto_1.getNewSubjectLifeCycle());//sourceId:310382_1
retData.setNewIsArchive(queryTopMidBatchDataDetailRespDto_1.getNewIsArchive());//sourceId:310383_1
retData.setNewIsEditing(queryTopMidBatchDataDetailRespDto_1.getNewIsEditing());//sourceId:310384_1
retData.setBatchId(queryTopMidBatchDataDetailRespDto_1.getBatchId());//sourceId:323516_1
retData.setBatchCode(queryTopMidBatchDataDetailRespDto_1.getBatchCode());//sourceId:329213_1
retData.setIsFirst(queryTopMidBatchDataDetailRespDto_1.getIsFirst());//sourceId:310386_1
retData.setIsNewbatch(queryTopMidBatchDataDetailRespDto_1.getIsNewbatch());//sourceId:310387_1
retData.setSubjectLifeCycle(queryTopMidBatchDataDetailRespDto_1.getSubjectLifeCycle());//sourceId:310388_1
retData.setIsArchive(queryTopMidBatchDataDetailRespDto_1.getIsArchive());//sourceId:310389_1
retData.setIsEditing(queryTopMidBatchDataDetailRespDto_1.getIsEditing());//sourceId:310390_1
retData.setBatchRelatedSetId(queryTopMidBatchDataDetailRespDto_1.getBatchRelatedSetId());//sourceId:310391_1
retData.setBatchProcessProgress(queryTopMidBatchDataDetailRespDto_1.getBatchProcessProgress());//sourceId:310392_1
retData.setDelBatchIsDone(queryTopMidBatchDataDetailRespDto_1.getDelBatchIsDone());//sourceId:310393_1
retData.setCurrentManageObjectType(queryTopMidBatchDataDetailRespDto_1.getCurrentManageObjectType());//sourceId:310394_1
retData.setManageLockStatus(queryTopMidBatchDataDetailRespDto_1.getManageLockStatus());//sourceId:310395_1
retData.setReasonOfManageLock(queryTopMidBatchDataDetailRespDto_1.getReasonOfManageLock());//sourceId:310396_1
retData.setReasonOfUsingLock(queryTopMidBatchDataDetailRespDto_1.getReasonOfUsingLock());//sourceId:310397_1
retData.setUsingLockStatus(queryTopMidBatchDataDetailRespDto_1.getUsingLockStatus());//sourceId:310398_1
retData.setIsUnifiedMgt(queryTopMidBatchDataDetailRespDto_1.getIsUnifiedMgt());//sourceId:310399_1
retData.setStatusCheckItemId(queryTopMidBatchDataDetailRespDto_1.getStatusCheckItemId());//sourceId:310400_1
retData.setIsComplete(queryTopMidBatchDataDetailRespDto_1.getIsComplete());//sourceId:310401_1
    }
  

  
  
return retData;
  }
/**
   * B3一键构造单条指标验证数据(管理)[4400]
   * gen by moon at 9/14/2022, 3:41:59 AM
   */
    @Trace(operationName = "B3一键构造单条指标验证数据(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffAutoBuildSingleTargetObjectiveRespDto autoBuildSingleTargetObjective(BffAutoBuildSingleTargetObjectiveReqDto reqDto){
      
       
       AutoBuildSingleTargetObjectiveRespDto autoBuildSingleTargetObjectiveRespDto_1 =null;
//步骤0: D3一键构造单条指标验证数据 - autoBuildSingleTargetObjective
     AutoBuildSingleTargetObjectiveRespDto autoBuildSingleTargetObjectiveRespDto = null;
    AutoBuildSingleTargetObjectiveReqDto autoBuildSingleTargetObjectiveReqDto=new AutoBuildSingleTargetObjectiveReqDto();
  if(reqDto!=null){
      autoBuildSingleTargetObjectiveReqDto.setObjectiveName(reqDto.getObjectiveName());//sourceId:308616_1
autoBuildSingleTargetObjectiveReqDto.setObjectiveShortName(reqDto.getObjectiveShortName());//sourceId:308617_1
autoBuildSingleTargetObjectiveReqDto.setObjectiveCode(reqDto.getObjectiveCode());//sourceId:308618_1
autoBuildSingleTargetObjectiveReqDto.setTargetType(reqDto.getTargetType());//sourceId:308619_1
autoBuildSingleTargetObjectiveReqDto.setIsLastObjective(reqDto.getIsLastObjective());//sourceId:308621_1
autoBuildSingleTargetObjectiveReqDto.setParentObjectiveId(reqDto.getParentObjectiveId());//sourceId:308622_1
autoBuildSingleTargetObjectiveReqDto.setPeriodicModeTypeCode(reqDto.getPeriodicModeTypeCode());//sourceId:308623_1
autoBuildSingleTargetObjectiveReqDto.setLevelNumber(reqDto.getLevelNumber());//sourceId:308624_1
autoBuildSingleTargetObjectiveReqDto.setOrderNumber(reqDto.getOrderNumber());//sourceId:308625_1
autoBuildSingleTargetObjectiveReqDto.setBatchCode(reqDto.getBatchCode());//sourceId:308614_1
autoBuildSingleTargetObjectiveReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//sourceId:308615_1
autoBuildSingleTargetObjectiveReqDto.setRespBodyType(reqDto.getRespBodyType());//sourceId:320115_1
autoBuildSingleTargetObjectiveReqDto.setDeptId(reqDto.getDeptId());//sourceId:320116_1
autoBuildSingleTargetObjectiveReqDto.setVirtualOrgInductionRecordId(reqDto.getVirtualOrgInductionRecordId());//sourceId:320117_1
autoBuildSingleTargetObjectiveReqDto.setRoleCode(reqDto.getRoleCode());//sourceId:320118_1
    }
  
    /*D3一键构造单条指标验证数据[4397]   */
    Assert.isNull(autoBuildSingleTargetObjectiveReqDto.getObjectiveName(),"B3一键构造单条指标验证数据(管理)-D3一键构造单条指标验证数据-指标名称不能为空",false);
Assert.isNull(autoBuildSingleTargetObjectiveReqDto.getObjectiveShortName(),"B3一键构造单条指标验证数据(管理)-D3一键构造单条指标验证数据-指标简称不能为空",false);
Assert.isNull(autoBuildSingleTargetObjectiveReqDto.getObjectiveCode(),"B3一键构造单条指标验证数据(管理)-D3一键构造单条指标验证数据-指标标识不能为空",false);
Assert.isNull(autoBuildSingleTargetObjectiveReqDto.getTargetType(),"B3一键构造单条指标验证数据(管理)-D3一键构造单条指标验证数据-目标类型不能为空",false);
//Assert.isNull(autoBuildSingleTargetObjectiveReqDto.getIsUseFirstDept(),"B3一键构造单条指标验证数据(管理)-D3一键构造单条指标验证数据-是否用于一级部门不能为空",false);
Assert.isNull(autoBuildSingleTargetObjectiveReqDto.getIsLastObjective(),"B3一键构造单条指标验证数据(管理)-D3一键构造单条指标验证数据-是否末级指标不能为空",false);
//Assert.isNull(autoBuildSingleTargetObjectiveReqDto.getParentObjectiveId(),"B3一键构造单条指标验证数据(管理)-D3一键构造单条指标验证数据-归属父级指标ID不能为空",false);
Assert.isNull(autoBuildSingleTargetObjectiveReqDto.getPeriodicModeTypeCode(),"B3一键构造单条指标验证数据(管理)-D3一键构造单条指标验证数据-周期模式类型编码不能为空",false);
Assert.isNull(autoBuildSingleTargetObjectiveReqDto.getLevelNumber(),"B3一键构造单条指标验证数据(管理)-D3一键构造单条指标验证数据-层级不能为空",false);
Assert.isNull(autoBuildSingleTargetObjectiveReqDto.getOrderNumber(),"B3一键构造单条指标验证数据(管理)-D3一键构造单条指标验证数据-排序不能为空",false);
Assert.isNull(autoBuildSingleTargetObjectiveReqDto.getBatchCode(),"B3一键构造单条指标验证数据(管理)-D3一键构造单条指标验证数据-批次标识不能为空",false);
Assert.isNull(autoBuildSingleTargetObjectiveReqDto.getSubjectLifeCycle(),"B3一键构造单条指标验证数据(管理)-D3一键构造单条指标验证数据-主体生命周期不能为空",false);
Assert.isNull(autoBuildSingleTargetObjectiveReqDto.getRespBodyType(),"B3一键构造单条指标验证数据(管理)-D3一键构造单条指标验证数据-责任主体类型不能为空",false);
      autoBuildSingleTargetObjectiveRespDto = fwAppSystemTestDomainClient.autoBuildSingleTargetObjective(autoBuildSingleTargetObjectiveReqDto).getData();
      
      
      autoBuildSingleTargetObjectiveRespDto_1 = autoBuildSingleTargetObjectiveRespDto;
    
BffAutoBuildSingleTargetObjectiveRespDto retData = new BffAutoBuildSingleTargetObjectiveRespDto();
  if(autoBuildSingleTargetObjectiveRespDto_1!=null){
      retData.setObjectiveId(autoBuildSingleTargetObjectiveRespDto_1.getObjectiveId());//sourceId:308646_1
    }
  

  
  
return retData;
  }
/**
   * B3一键构造单条被评对象目标周期验证数据[4411]
   * gen by moon at 9/12/2022, 10:16:14 PM
   */
    @Trace(operationName = "B3一键构造单条被评对象目标周期验证数据")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffAutoBuildSingleEvaObjTarCycRespDto autoBuildSingleEvaObjTarCyc(BffAutoBuildSingleEvaObjTarCycReqDto reqDto){
      
       
       AutoBuildSingleEvaObjTarCycRespDto autoBuildSingleEvaObjTarCycRespDto_1 =null;
//步骤0: D3一键构造单条被评对象目标周期验证数据 - autoBuildSingleEvaObjTarCyc
     AutoBuildSingleEvaObjTarCycRespDto autoBuildSingleEvaObjTarCycRespDto = null;
    AutoBuildSingleEvaObjTarCycReqDto autoBuildSingleEvaObjTarCycReqDto=new AutoBuildSingleEvaObjTarCycReqDto();
  if(reqDto!=null){
      autoBuildSingleEvaObjTarCycReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//sourceId:310730_1
autoBuildSingleEvaObjTarCycReqDto.setEvaObjTableTypeCode(reqDto.getEvaObjTableTypeCode());//sourceId:310731_1
autoBuildSingleEvaObjTarCycReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//sourceId:310732_1
autoBuildSingleEvaObjTarCycReqDto.setTreeTypeCode(reqDto.getTreeTypeCode());//sourceId:310733_1
autoBuildSingleEvaObjTarCycReqDto.setSuperiorTargetCycleContentTypeCode(reqDto.getSuperiorTargetCycleContentTypeCode());//sourceId:310734_1
autoBuildSingleEvaObjTarCycReqDto.setSuperiorTargetCycleContentId(reqDto.getSuperiorTargetCycleContentId());//sourceId:310735_1
autoBuildSingleEvaObjTarCycReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//sourceId:310736_1
autoBuildSingleEvaObjTarCycReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//sourceId:310737_1
autoBuildSingleEvaObjTarCycReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//sourceId:310738_1
autoBuildSingleEvaObjTarCycReqDto.setTaskStatus(reqDto.getTaskStatus());//sourceId:310739_1
autoBuildSingleEvaObjTarCycReqDto.setLogicalOperator(reqDto.getLogicalOperator());//sourceId:310740_1
autoBuildSingleEvaObjTarCycReqDto.setTargetDiagnosticValue(reqDto.getTargetDiagnosticValue());//sourceId:310741_1
autoBuildSingleEvaObjTarCycReqDto.setWeightScore(reqDto.getWeightScore());//sourceId:310742_1
autoBuildSingleEvaObjTarCycReqDto.setWeightValue(reqDto.getWeightValue());//sourceId:310743_1
    }
  
    /*D3一键构造单条被评对象目标周期验证数据[4410]   */
    Assert.isNull(autoBuildSingleEvaObjTarCycReqDto.getEvaObjEntityId(),"B3一键构造单条被评对象目标周期验证数据-D3一键构造单条被评对象目标周期验证数据-被评对象内容表主键ID不能为空",false);
Assert.isNull(autoBuildSingleEvaObjTarCycReqDto.getEvaObjTableTypeCode(),"B3一键构造单条被评对象目标周期验证数据-D3一键构造单条被评对象目标周期验证数据-被评对象内容表类型编码不能为空",false);
Assert.isNull(autoBuildSingleEvaObjTarCycReqDto.getEvaObjTypeCode(),"B3一键构造单条被评对象目标周期验证数据-D3一键构造单条被评对象目标周期验证数据-被评对象类型编码不能为空",false);
Assert.isNull(autoBuildSingleEvaObjTarCycReqDto.getTreeTypeCode(),"B3一键构造单条被评对象目标周期验证数据-D3一键构造单条被评对象目标周期验证数据-树类型编码不能为空",false);
Assert.isNull(autoBuildSingleEvaObjTarCycReqDto.getTargetCycleContentTypeCode(),"B3一键构造单条被评对象目标周期验证数据-D3一键构造单条被评对象目标周期验证数据-关联目标内容类型编码不能为空",false);
Assert.isNull(autoBuildSingleEvaObjTarCycReqDto.getTargetCycleContentId(),"B3一键构造单条被评对象目标周期验证数据-D3一键构造单条被评对象目标周期验证数据-关联目标内容ID不能为空",false);
Assert.isNull(autoBuildSingleEvaObjTarCycReqDto.getEvaluationTemplateId(),"B3一键构造单条被评对象目标周期验证数据-D3一键构造单条被评对象目标周期验证数据-评价模板ID不能为空",false);
Assert.isNull(autoBuildSingleEvaObjTarCycReqDto.getTaskStatus(),"B3一键构造单条被评对象目标周期验证数据-D3一键构造单条被评对象目标周期验证数据-目标周期任务进展状态不能为空",false);
      autoBuildSingleEvaObjTarCycRespDto = fwAppSystemTestDomainClient.autoBuildSingleEvaObjTarCyc(autoBuildSingleEvaObjTarCycReqDto).getData();
      
      
      autoBuildSingleEvaObjTarCycRespDto_1 = autoBuildSingleEvaObjTarCycRespDto;
    
BffAutoBuildSingleEvaObjTarCycRespDto retData = new BffAutoBuildSingleEvaObjTarCycRespDto();
  if(autoBuildSingleEvaObjTarCycRespDto_1!=null){
      retData.setEvaObjTargetCycleId(autoBuildSingleEvaObjTarCycRespDto_1.getEvaObjTargetCycleId());//sourceId:313461_1
    }
  

  
  
return retData;
  }
/**
   * B3一键删除单条指标验证数据(管理)[4415]
   * gen by moon at 9/7/2022, 1:50:03 AM
   */
    @Trace(operationName = "B3一键删除单条指标验证数据(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffAutoDeleteSingleTargetObjectiveRespDto autoDeleteSingleTargetObjective(BffAutoDeleteSingleTargetObjectiveReqDto reqDto){
      
       
       //步骤0: D3一键删除单条指标验证数据 - autoDeleteSingleTargetObjective
     AutoDeleteSingleTargetObjectiveRespDto autoDeleteSingleTargetObjectiveRespDto = null;
    AutoDeleteSingleTargetObjectiveReqDto autoDeleteSingleTargetObjectiveReqDto=new AutoDeleteSingleTargetObjectiveReqDto();
  if(reqDto!=null){
      autoDeleteSingleTargetObjectiveReqDto.setObjectiveId(reqDto.getObjectiveId());//sourceId:312516_1
    }
  
    /*D3一键删除单条指标验证数据[4413]   */
    Assert.isNull(autoDeleteSingleTargetObjectiveReqDto.getObjectiveId(),"B3一键删除单条指标验证数据(管理)-D3一键删除单条指标验证数据-指标ID不能为空",false);
      autoDeleteSingleTargetObjectiveRespDto = fwAppSystemTestDomainClient.autoDeleteSingleTargetObjective(autoDeleteSingleTargetObjectiveReqDto).getData();
      
      
      
    
BffAutoDeleteSingleTargetObjectiveRespDto retData = new BffAutoDeleteSingleTargetObjectiveRespDto();
  
  

  
  
return retData;
  }
/**
   * B3一键删除单条被评对象目标周期验证数据(管理)[4416]
   * gen by moon at 9/7/2022, 1:50:05 AM
   */
    @Trace(operationName = "B3一键删除单条被评对象目标周期验证数据(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffAutoDeleteSingleEvaObjTarCycRespDto autoDeleteSingleEvaObjTarCyc(BffAutoDeleteSingleEvaObjTarCycReqDto reqDto){
      
       
       //步骤0: D3-3-09删除单条被评对象目标周期(公共) - deleteSingleEvaObjTarCycCom
     DeleteSingleEvaObjTarCycComRespDto deleteSingleEvaObjTarCycComRespDto = null;
    DeleteSingleEvaObjTarCycComReqDto deleteSingleEvaObjTarCycComReqDto=new DeleteSingleEvaObjTarCycComReqDto();
  if(reqDto!=null){
      deleteSingleEvaObjTarCycComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//sourceId:312514_1
    }
  
    /*D3-3-09删除单条被评对象目标周期(公共)[4443]   */
    Assert.isNull(deleteSingleEvaObjTarCycComReqDto.getEvaObjTargetCycleId(),"B3一键删除单条被评对象目标周期验证数据(管理)-D3-3-09删除单条被评对象目标周期(公共)-被评对象目标周期ID不能为空",false);
      deleteSingleEvaObjTarCycComRespDto = fwAppSystemTestDomainClient.deleteSingleEvaObjTarCycCom(deleteSingleEvaObjTarCycComReqDto).getData();
      
      
      
    
BffAutoDeleteSingleEvaObjTarCycRespDto retData = new BffAutoDeleteSingleEvaObjTarCycRespDto();
  
  

  
  
return retData;
  }
/**
   * B3一键构造父子状态检查项等测试验证数据（真实接口）[4477]
   * gen by moon at 10/20/2022, 10:07:01 AM
   */
    @Trace(operationName = "B3一键构造父子状态检查项等测试验证数据（真实接口）")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffAutoBuildAssistNnodeStatusEtcTestRespDto autoBuildAssistNnodeStatusEtcTest(BffAutoBuildAssistNnodeStatusEtcTestReqDto reqDto){
      
       
       //步骤0: D3一键构造父子状态检查项等测试验证数据 - autoBuildAssistNnodeStatusEtcTest
     AutoBuildAssistNnodeStatusEtcTestRespDto autoBuildAssistNnodeStatusEtcTestRespDto = null;
    AutoBuildAssistNnodeStatusEtcTestReqDto autoBuildAssistNnodeStatusEtcTestReqDto=new AutoBuildAssistNnodeStatusEtcTestReqDto();
  if(reqDto!=null){
      autoBuildAssistNnodeStatusEtcTestReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:374038_1
autoBuildAssistNnodeStatusEtcTestReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:374039_1
autoBuildAssistNnodeStatusEtcTestReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:374040_1
    }
  
    /*D3一键构造父子状态检查项等测试验证数据[4478]   */
    Assert.isNull(autoBuildAssistNnodeStatusEtcTestReqDto.getEvaluationTemplateId(),"B3一键构造父子状态检查项等测试验证数据（真实接口）-D3一键构造父子状态检查项等测试验证数据-冗余评价模板ID不能为空",false);
Assert.isNull(autoBuildAssistNnodeStatusEtcTestReqDto.getTableTypeCode(),"B3一键构造父子状态检查项等测试验证数据（真实接口）-D3一键构造父子状态检查项等测试验证数据-内容表类型编码不能为空",false);
Assert.isNull(autoBuildAssistNnodeStatusEtcTestReqDto.getEntityId(),"B3一键构造父子状态检查项等测试验证数据（真实接口）-D3一键构造父子状态检查项等测试验证数据-内容表主键ID不能为空",false);
      autoBuildAssistNnodeStatusEtcTestRespDto = fwAppSystemTestDomainClient.autoBuildAssistNnodeStatusEtcTest(autoBuildAssistNnodeStatusEtcTestReqDto).getData();
      
      
      
    
BffAutoBuildAssistNnodeStatusEtcTestRespDto retData = new BffAutoBuildAssistNnodeStatusEtcTestRespDto();
  
  

  
  
return retData;
  }
/**
   * B3-一键构造状态检查项验证数据（管理）[4481]
   * gen by moon at 9/8/2022, 4:07:23 AM
   */
    @Trace(operationName = "B3-一键构造状态检查项验证数据（管理）")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffAutoBuildStatusCheckItemRespDto autoBuildStatusCheckItem(BffAutoBuildStatusCheckItemReqDto reqDto){
      
       
       AutoBuildStatusCheckItemTestRespDto autoBuildStatusCheckItemTestRespDto_1 =null;
//步骤0: D3一键构造检查项状态测试验证数据 - autoBuildStatusCheckItemTest
     AutoBuildStatusCheckItemTestRespDto autoBuildStatusCheckItemTestRespDto = null;
    AutoBuildStatusCheckItemTestReqDto autoBuildStatusCheckItemTestReqDto=new AutoBuildStatusCheckItemTestReqDto();
  if(reqDto!=null){
      autoBuildStatusCheckItemTestReqDto.setEntityId(reqDto.getEntityId());//sourceId:313350_1
autoBuildStatusCheckItemTestReqDto.setObjectTypeCode(reqDto.getObjectTypeCode());//sourceId:313351_1
autoBuildStatusCheckItemTestReqDto.setCheckItemCode(reqDto.getCheckItemCode());//sourceId:313352_1
autoBuildStatusCheckItemTestReqDto.setUpdateStatusCheckItemId(reqDto.getUpdateStatusCheckItemId());//sourceId:313701_1
autoBuildStatusCheckItemTestReqDto.setIsComplete(reqDto.getIsComplete());//sourceId:313354_1
autoBuildStatusCheckItemTestReqDto.setCreateInductionId(reqDto.getCreateInductionId());//sourceId:313355_1
autoBuildStatusCheckItemTestReqDto.setSpaceId(reqDto.getSpaceId());//sourceId:313356_1
autoBuildStatusCheckItemTestReqDto.setAppId(reqDto.getAppId());//sourceId:313357_1
    }
  
    /*D3一键构造检查项状态测试验证数据[4482]   */
    Assert.isNull(autoBuildStatusCheckItemTestReqDto.getCreateInductionId(),"B3-一键构造状态检查项验证数据（管理）-D3一键构造检查项状态测试验证数据-创建人就职记录ID 不能为空",false);
Assert.isNull(autoBuildStatusCheckItemTestReqDto.getSpaceId(),"B3-一键构造状态检查项验证数据（管理）-D3一键构造检查项状态测试验证数据-创建于空间ID不能为空",false);
Assert.isNull(autoBuildStatusCheckItemTestReqDto.getAppId(),"B3-一键构造状态检查项验证数据（管理）-D3一键构造检查项状态测试验证数据-创建于联盟应用ID不能为空",false);
      autoBuildStatusCheckItemTestRespDto = fwAppSystemTestDomainClient.autoBuildStatusCheckItemTest(autoBuildStatusCheckItemTestReqDto).getData();
      
      
      autoBuildStatusCheckItemTestRespDto_1 = autoBuildStatusCheckItemTestRespDto;
    
BffAutoBuildStatusCheckItemRespDto retData = new BffAutoBuildStatusCheckItemRespDto();
  if(autoBuildStatusCheckItemTestRespDto_1!=null){
      retData.setStatusCheckItemId(autoBuildStatusCheckItemTestRespDto_1.getStatusCheckItemId());//sourceId:313366_1
    }
  

  
  
return retData;
  }
/**
   * B3-一键构造检查仪表盘测试验证数据（管理）[4490]
   * gen by moon at 9/8/2022, 4:07:24 AM
   */
    @Trace(operationName = "B3-一键构造检查仪表盘测试验证数据（管理）")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffAutoBuildAssistCheckPanelTestRespDto autoBuildAssistCheckPanelTest(BffAutoBuildAssistCheckPanelTestReqDto reqDto){
      
       
       AutoBuildAssistCheckPanelTestRespDto autoBuildAssistCheckPanelTestRespDto_1 =null;
//步骤0: D3-一键构造检查仪表盘测试验证数据 - autoBuildAssistCheckPanelTest
     AutoBuildAssistCheckPanelTestRespDto autoBuildAssistCheckPanelTestRespDto = null;
    AutoBuildAssistCheckPanelTestReqDto autoBuildAssistCheckPanelTestReqDto=new AutoBuildAssistCheckPanelTestReqDto();
  if(reqDto!=null){
      autoBuildAssistCheckPanelTestReqDto.setCheckObjectTypeCode(reqDto.getCheckObjectTypeCode());//sourceId:313678_1
autoBuildAssistCheckPanelTestReqDto.setCheckObjectTypeId(reqDto.getCheckObjectTypeId());//sourceId:313679_1
autoBuildAssistCheckPanelTestReqDto.setCheckItemCode(reqDto.getCheckItemCode());//sourceId:313680_1
autoBuildAssistCheckPanelTestReqDto.setTargetValue(reqDto.getTargetValue());//sourceId:313681_1
autoBuildAssistCheckPanelTestReqDto.setActualValue(reqDto.getActualValue());//sourceId:313682_1
autoBuildAssistCheckPanelTestReqDto.setUpdateCheckItemPanelUpdateId(reqDto.getUpdateCheckItemPanelUpdateId());//sourceId:313683_1
autoBuildAssistCheckPanelTestReqDto.setCreateInductionId(reqDto.getCreateInductionId());//sourceId:313684_1
autoBuildAssistCheckPanelTestReqDto.setSpaceId(reqDto.getSpaceId());//sourceId:313685_1
autoBuildAssistCheckPanelTestReqDto.setAppId(reqDto.getAppId());//sourceId:313686_1
    }
  
    /*D3-一键构造检查仪表盘测试验证数据[4491]   */
    Assert.isNull(autoBuildAssistCheckPanelTestReqDto.getCreateInductionId(),"B3-一键构造检查仪表盘测试验证数据（管理）-D3-一键构造检查仪表盘测试验证数据-创建人就职记录ID 不能为空",false);
Assert.isNull(autoBuildAssistCheckPanelTestReqDto.getSpaceId(),"B3-一键构造检查仪表盘测试验证数据（管理）-D3-一键构造检查仪表盘测试验证数据-创建于空间ID不能为空",false);
Assert.isNull(autoBuildAssistCheckPanelTestReqDto.getAppId(),"B3-一键构造检查仪表盘测试验证数据（管理）-D3-一键构造检查仪表盘测试验证数据-创建于联盟应用ID不能为空",false);
      autoBuildAssistCheckPanelTestRespDto = fwAppSystemTestDomainClient.autoBuildAssistCheckPanelTest(autoBuildAssistCheckPanelTestReqDto).getData();
      
      
      autoBuildAssistCheckPanelTestRespDto_1 = autoBuildAssistCheckPanelTestRespDto;
    
BffAutoBuildAssistCheckPanelTestRespDto retData = new BffAutoBuildAssistCheckPanelTestRespDto();
  if(autoBuildAssistCheckPanelTestRespDto_1!=null){
      retData.setCheckItemPanelUpdateId(autoBuildAssistCheckPanelTestRespDto_1.getCheckItemPanelUpdateId());//sourceId:313698_1
    }
  

  
  
return retData;
  }
/**
   * B3一键构造单条目标分类验证数据(管理）[4318]
   * gen by moon at 9/14/2022, 3:41:57 AM
   */
    @Trace(operationName = "B3一键构造单条目标分类验证数据(管理）")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffAutoBuildSingleTargetCategoryRespDto autoBuildSingleTargetCategory(BffAutoBuildSingleTargetCategoryReqDto reqDto){
      
       
       AutoBuildSingleTargetCategoryRespDto autoBuildSingleTargetCategoryRespDto_1 =null;
//步骤0: D3-一键构造单条目标分类验证数据 - autoBuildSingleTargetCategory
     AutoBuildSingleTargetCategoryRespDto autoBuildSingleTargetCategoryRespDto = null;
    AutoBuildSingleTargetCategoryReqDto autoBuildSingleTargetCategoryReqDto=new AutoBuildSingleTargetCategoryReqDto();
  if(reqDto!=null){
      autoBuildSingleTargetCategoryReqDto.setTargetCategoryCode(reqDto.getTargetCategoryCode());//sourceId:317471_1
autoBuildSingleTargetCategoryReqDto.setTargetCategoryName(reqDto.getTargetCategoryName());//sourceId:317477_1
autoBuildSingleTargetCategoryReqDto.setTargetCategoryDescribe(reqDto.getTargetCategoryDescribe());//sourceId:317478_1
autoBuildSingleTargetCategoryReqDto.setTargetCategoryRemarks(reqDto.getTargetCategoryRemarks());//sourceId:317479_1
autoBuildSingleTargetCategoryReqDto.setParentTtargetCategoryId(reqDto.getParentTtargetCategoryId());//sourceId:317472_1
autoBuildSingleTargetCategoryReqDto.setRootTargetCategoryId(reqDto.getRootTargetCategoryId());//sourceId:317480_1
autoBuildSingleTargetCategoryReqDto.setIsLast(reqDto.getIsLast());//sourceId:317473_1
autoBuildSingleTargetCategoryReqDto.setPeriodicModeTypeCode(reqDto.getPeriodicModeTypeCode());//sourceId:317474_1
autoBuildSingleTargetCategoryReqDto.setReportObjectSetCode(reqDto.getReportObjectSetCode());//sourceId:317484_1
autoBuildSingleTargetCategoryReqDto.setLevelNumber(reqDto.getLevelNumber());//sourceId:317475_1
autoBuildSingleTargetCategoryReqDto.setOrderNumber(reqDto.getOrderNumber());//sourceId:317476_1
autoBuildSingleTargetCategoryReqDto.setBatchCode(reqDto.getBatchCode());//sourceId:317469_1
autoBuildSingleTargetCategoryReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//sourceId:317470_1
autoBuildSingleTargetCategoryReqDto.setCreateInductionId(reqDto.getCreateInductionId());//sourceId:317467_1
autoBuildSingleTargetCategoryReqDto.setSpaceId(reqDto.getSpaceId());//sourceId:317466_1
autoBuildSingleTargetCategoryReqDto.setAppId(reqDto.getAppId());//sourceId:317468_1
autoBuildSingleTargetCategoryReqDto.setVirtualOrgInductionRecordId(reqDto.getVirtualOrgInductionRecordId());//sourceId:317481_1
autoBuildSingleTargetCategoryReqDto.setRoleCode(reqDto.getRoleCode());//sourceId:317483_1
autoBuildSingleTargetCategoryReqDto.setDeptId(reqDto.getDeptId());//sourceId:317482_1
    }
  
    /*D3-一键构造单条目标分类验证数据[4319]   */
    Assert.isNull(autoBuildSingleTargetCategoryReqDto.getTargetCategoryCode(),"B3一键构造单条目标分类验证数据(管理）-D3-一键构造单条目标分类验证数据-目标分类标识不能为空",false);
Assert.isNull(autoBuildSingleTargetCategoryReqDto.getTargetCategoryName(),"B3一键构造单条目标分类验证数据(管理）-D3-一键构造单条目标分类验证数据-目标分类名称不能为空",false);
Assert.isNull(autoBuildSingleTargetCategoryReqDto.getIsLast(),"B3一键构造单条目标分类验证数据(管理）-D3-一键构造单条目标分类验证数据-目标分类是否末级不能为空",false);
Assert.isNull(autoBuildSingleTargetCategoryReqDto.getPeriodicModeTypeCode(),"B3一键构造单条目标分类验证数据(管理）-D3-一键构造单条目标分类验证数据-周期模式类型编码不能为空",false);
Assert.isNull(autoBuildSingleTargetCategoryReqDto.getReportObjectSetCode(),"B3一键构造单条目标分类验证数据(管理）-D3-一键构造单条目标分类验证数据-建设任务汇报对象设置项编码不能为空",false);
Assert.isNull(autoBuildSingleTargetCategoryReqDto.getLevelNumber(),"B3一键构造单条目标分类验证数据(管理）-D3-一键构造单条目标分类验证数据-层级不能为空",false);
Assert.isNull(autoBuildSingleTargetCategoryReqDto.getOrderNumber(),"B3一键构造单条目标分类验证数据(管理）-D3-一键构造单条目标分类验证数据-排序不能为空",false);
Assert.isNull(autoBuildSingleTargetCategoryReqDto.getBatchCode(),"B3一键构造单条目标分类验证数据(管理）-D3-一键构造单条目标分类验证数据-批次标识不能为空",false);
Assert.isNull(autoBuildSingleTargetCategoryReqDto.getSubjectLifeCycle(),"B3一键构造单条目标分类验证数据(管理）-D3-一键构造单条目标分类验证数据-主体生命周期不能为空",false);
Assert.isNull(autoBuildSingleTargetCategoryReqDto.getCreateInductionId(),"B3一键构造单条目标分类验证数据(管理）-D3-一键构造单条目标分类验证数据-创建人就职记录ID 不能为空",false);
Assert.isNull(autoBuildSingleTargetCategoryReqDto.getSpaceId(),"B3一键构造单条目标分类验证数据(管理）-D3-一键构造单条目标分类验证数据-创建于空间ID不能为空",false);
Assert.isNull(autoBuildSingleTargetCategoryReqDto.getAppId(),"B3一键构造单条目标分类验证数据(管理）-D3-一键构造单条目标分类验证数据-创建于联盟应用ID不能为空",false);
Assert.isNull(autoBuildSingleTargetCategoryReqDto.getVirtualOrgInductionRecordId(),"B3一键构造单条目标分类验证数据(管理）-D3-一键构造单条目标分类验证数据-负责人就职记录ID不能为空",false);
Assert.isNull(autoBuildSingleTargetCategoryReqDto.getRoleCode(),"B3一键构造单条目标分类验证数据(管理）-D3-一键构造单条目标分类验证数据-负责人角色标识不能为空",false);
Assert.isNull(autoBuildSingleTargetCategoryReqDto.getDeptId(),"B3一键构造单条目标分类验证数据(管理）-D3-一键构造单条目标分类验证数据-牵头部门ID不能为空",false);
      autoBuildSingleTargetCategoryRespDto = fwAppSystemTestDomainClient.autoBuildSingleTargetCategory(autoBuildSingleTargetCategoryReqDto).getData();
      
      
      autoBuildSingleTargetCategoryRespDto_1 = autoBuildSingleTargetCategoryRespDto;
    
BffAutoBuildSingleTargetCategoryRespDto retData = new BffAutoBuildSingleTargetCategoryRespDto();
  if(autoBuildSingleTargetCategoryRespDto_1!=null){
      retData.setTargetCategoryId(autoBuildSingleTargetCategoryRespDto_1.getTargetCategoryId());//sourceId:317506_1
    }
  

  
  
return retData;
  }
/**
   * B3一键删除单条目标分类验证数据(管理)[4510]
   * gen by moon at 11/4/2022, 7:39:28 AM
   */
    @Trace(operationName = "B3一键删除单条目标分类验证数据(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffAutoDeleteSingleTargetCategoryRespDto autoDeleteSingleTargetCategory(BffAutoDeleteSingleTargetCategoryReqDto reqDto){
      
       
       //步骤0: D3一键删除单条目标分类验证数据(公共) - autoDeleteSingleTargetCategoryCom
     AutoDeleteSingleTargetCategoryComRespDto autoDeleteSingleTargetCategoryComRespDto = null;
    AutoDeleteSingleTargetCategoryComReqDto autoDeleteSingleTargetCategoryComReqDto=new AutoDeleteSingleTargetCategoryComReqDto();
  if(reqDto!=null){
      autoDeleteSingleTargetCategoryComReqDto.setTargetCategoryId(reqDto.getTargetCategoryId());//SimpleFieldAssign//sourceId:317545_1
    }
  
    /*D3一键删除单条目标分类验证数据(公共)[4509]   */
    Assert.isNull(autoDeleteSingleTargetCategoryComReqDto.getTargetCategoryId(),"B3一键删除单条目标分类验证数据(管理)-D3一键删除单条目标分类验证数据(公共)-目标分类ID不能为空",false);
      autoDeleteSingleTargetCategoryComRespDto = fwAppSystemTestDomainClient.autoDeleteSingleTargetCategoryCom(autoDeleteSingleTargetCategoryComReqDto).getData();
      
      
      
    
BffAutoDeleteSingleTargetCategoryRespDto retData = new BffAutoDeleteSingleTargetCategoryRespDto();
  
  

  
  
return retData;
  }
/**
   * B3一键构造单条被评对象目标周期标准数据验证数据[4502]
   * gen by moon at 10/17/2022, 6:42:05 PM
   */
    @Trace(operationName = "B3一键构造单条被评对象目标周期标准数据验证数据")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffAutoBuildSingleEvaObjTarCycStaDataRespDto autoBuildSingleEvaObjTarCycStaData(BffAutoBuildSingleEvaObjTarCycStaDataReqDto reqDto){
      
       
       //步骤0: D3-3查询单条目标详情 - querySingleTargetDetail
     QuerySingleTargetDetailRespDto querySingleTargetDetailRespDto = null;
    QuerySingleTargetDetailReqDto querySingleTargetDetailReqDto=new QuerySingleTargetDetailReqDto();
  if(reqDto!=null){
      querySingleTargetDetailReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:317410_1
    }
  
    /*D3-3查询单条目标详情[3576]   */
    Assert.isNull(querySingleTargetDetailReqDto.getTargetId(),"B3一键构造单条被评对象目标周期标准数据验证数据-D3-3查询单条目标详情-目标ID不能为空",false);
      querySingleTargetDetailRespDto = fwAppSystemTestDomainClient.querySingleTargetDetail(querySingleTargetDetailReqDto).getData();
      
      
      
    
//步骤1: D3-推送业务应用公共字段缓存测试(公共) - putAppPublicFieldCacheCom
     //ModelCode: publicFieldCache
        PutAppPublicFieldCacheComRespDto publicFieldCacheRes = null;
    if(querySingleTargetDetailRespDto !=null){
          com.wicket.okrpbff.biz.service.dto.req.PutAppPublicFieldCacheComReqDto publicFieldCacheReq=new PutAppPublicFieldCacheComReqDto();
  if(querySingleTargetDetailRespDto!=null){
      publicFieldCacheReq.setCreateInductionId(querySingleTargetDetailRespDto.getCreateInductionId());//SimpleFieldAssign//sourceId:318921_1
publicFieldCacheReq.setSpaceId(querySingleTargetDetailRespDto.getSpaceId());//SimpleFieldAssign//sourceId:318922_1
publicFieldCacheReq.setAppId(querySingleTargetDetailRespDto.getAppId());//SimpleFieldAssign//sourceId:318923_1
    }
  
    /*D3-推送业务应用公共字段缓存测试(公共)[4523]  用于定时任务执行时，获取定时任务执行所需的公共信息，存入缓存，供定时任务中虚拟用况使用 */
    Assert.isNull(publicFieldCacheReq.getCreateInductionId(),"B3一键构造单条被评对象目标周期标准数据验证数据-D3-推送业务应用公共字段缓存测试(公共)-创建人就职记录ID 不能为空",false);
Assert.isNull(publicFieldCacheReq.getSpaceId(),"B3一键构造单条被评对象目标周期标准数据验证数据-D3-推送业务应用公共字段缓存测试(公共)-创建于空间ID不能为空",false);
Assert.isNull(publicFieldCacheReq.getAppId(),"B3一键构造单条被评对象目标周期标准数据验证数据-D3-推送业务应用公共字段缓存测试(公共)-创建于联盟应用ID不能为空",false);
      publicFieldCacheRes = nbSystemTestDomain.putAppPublicFieldCacheCom(publicFieldCacheReq);
      
      
      
           }
    
//步骤2: D3-一键构造被评对象目标周期标准数据验证数据(公共) - autoBuildEvaObjTarCycStaDataCom
     AutoBuildEvaObjTarCycStaDataComRespDto autoBuildEvaObjTarCycStaDataComRespDto = null;
    AutoBuildEvaObjTarCycStaDataComReqDto autoBuildEvaObjTarCycStaDataComReqDto=new AutoBuildEvaObjTarCycStaDataComReqDto();
  autoBuildEvaObjTarCycStaDataComReqDto.setBizRoleObjCode("PRINCIPAL");//CUSTOM_CONVENTION//sourceId:317036_1
autoBuildEvaObjTarCycStaDataComReqDto.setPersonLiableTypeCode("FILL_ROLE");//sourceId:317037_1
autoBuildEvaObjTarCycStaDataComReqDto.setBizRoleObjName("PRINCIPAL");//CUSTOM_CONVENTION//sourceId:317038_1
autoBuildEvaObjTarCycStaDataComReqDto.setProgressValueUnit("PERCENT");//sourceId:317020_1
autoBuildEvaObjTarCycStaDataComReqDto.setProgressFromLastRatioUnit("PERCENT");//sourceId:317022_1
autoBuildEvaObjTarCycStaDataComReqDto.setReachUnit("PERCENT");//sourceId:317026_1
autoBuildEvaObjTarCycStaDataComReqDto.setActualFromLastTimeRatioUnit("PERCENT");//sourceId:317028_1
autoBuildEvaObjTarCycStaDataComReqDto.setRealTimeScoreUnit("FEN");//CUSTOM_CONVENTION//sourceId:317030_1
autoBuildEvaObjTarCycStaDataComReqDto.setStageData("抽查计算机学院课程进度，目前进度正常，课程思政元素目前是做开放课程必要的前提，主要是课程标准的设计，把思政中立德树人放在第一位，主要是课程标准的设计");//CUSTOM_CONVENTION//sourceId:317042_1
autoBuildEvaObjTarCycStaDataComReqDto.setSummaryDataPic("http://www.suzhi.link/SPACE/REPORT_THUMBNAIL/DEFAULT/20220829/D5A394AB9E6F4A8EBFB1890EF48A21DF.jpeg");//CUSTOM_CONVENTION//sourceId:317043_1
autoBuildEvaObjTarCycStaDataComReqDto.setTextSummaryData("发起目标沟通会，确定各部门的目标任务，以及确定验收标准。");//CUSTOM_CONVENTION//sourceId:317044_1
if(reqDto!=null){
      autoBuildEvaObjTarCycStaDataComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:317031_1
autoBuildEvaObjTarCycStaDataComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:317047_1
autoBuildEvaObjTarCycStaDataComReqDto.setEvaObjTableTypeCode(reqDto.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:317041_1
autoBuildEvaObjTarCycStaDataComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:317039_1
autoBuildEvaObjTarCycStaDataComReqDto.setTreeTypeCode(reqDto.getTreeTypeCode());//SimpleFieldAssign//sourceId:317040_1
autoBuildEvaObjTarCycStaDataComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:317033_1
autoBuildEvaObjTarCycStaDataComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:317032_1
autoBuildEvaObjTarCycStaDataComReqDto.setPersonLiableObjId(reqDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:317034_1
autoBuildEvaObjTarCycStaDataComReqDto.setBizRoleObjId(reqDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:317035_1
autoBuildEvaObjTarCycStaDataComReqDto.setActualValue(reqDto.getActualValue());//SimpleFieldAssign//sourceId:317023_1
autoBuildEvaObjTarCycStaDataComReqDto.setActualValueUnit(reqDto.getActualValueUnit());//SimpleFieldAssign//sourceId:317024_1
autoBuildEvaObjTarCycStaDataComReqDto.setProgressValue(reqDto.getProgressValue());//SimpleFieldAssign//sourceId:317019_1
autoBuildEvaObjTarCycStaDataComReqDto.setProgressFromLastRatio(reqDto.getProgressFromLastRatio());//SimpleFieldAssign//sourceId:317021_1
autoBuildEvaObjTarCycStaDataComReqDto.setReach(reqDto.getReach());//SimpleFieldAssign//sourceId:317025_1
autoBuildEvaObjTarCycStaDataComReqDto.setActualFromLastTimeRatio(reqDto.getActualFromLastTimeRatio());//SimpleFieldAssign//sourceId:317027_1
autoBuildEvaObjTarCycStaDataComReqDto.setRealTimeScore(reqDto.getRealTimeScore());//SimpleFieldAssign//sourceId:317029_1
autoBuildEvaObjTarCycStaDataComReqDto.setFilledByInductionId(reqDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:317045_1
autoBuildEvaObjTarCycStaDataComReqDto.setEvaluationFillRoleId(reqDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:317046_1
    }
  
    /*D3-一键构造被评对象目标周期标准数据验证数据(公共)[4294]   */
    Assert.isNull(autoBuildEvaObjTarCycStaDataComReqDto.getProgressValueUnit(),"B3一键构造单条被评对象目标周期标准数据验证数据-D3-一键构造被评对象目标周期标准数据验证数据(公共)-进度值单位不能为空",false);
Assert.isNull(autoBuildEvaObjTarCycStaDataComReqDto.getProgressFromLastRatioUnit(),"B3一键构造单条被评对象目标周期标准数据验证数据-D3-一键构造被评对象目标周期标准数据验证数据(公共)-进度较上次增降幅单位不能为空",false);
Assert.isNull(autoBuildEvaObjTarCycStaDataComReqDto.getReachUnit(),"B3一键构造单条被评对象目标周期标准数据验证数据-D3-一键构造被评对象目标周期标准数据验证数据(公共)-达成度单位不能为空",false);
Assert.isNull(autoBuildEvaObjTarCycStaDataComReqDto.getActualFromLastTimeRatioUnit(),"B3一键构造单条被评对象目标周期标准数据验证数据-D3-一键构造被评对象目标周期标准数据验证数据(公共)-达成度较上次增降福单位不能为空",false);
Assert.isNull(autoBuildEvaObjTarCycStaDataComReqDto.getRealTimeScoreUnit(),"B3一键构造单条被评对象目标周期标准数据验证数据-D3-一键构造被评对象目标周期标准数据验证数据(公共)-实时得分单位不能为空",false);
Assert.isNull(autoBuildEvaObjTarCycStaDataComReqDto.getStageData(),"B3一键构造单条被评对象目标周期标准数据验证数据-D3-一键构造被评对象目标周期标准数据验证数据(公共)-阶段资料具体内容不能为空",false);
Assert.isNull(autoBuildEvaObjTarCycStaDataComReqDto.getSummaryDataPic(),"B3一键构造单条被评对象目标周期标准数据验证数据-D3-一键构造被评对象目标周期标准数据验证数据(公共)-资料图片概要地址不能为空",false);
Assert.isNull(autoBuildEvaObjTarCycStaDataComReqDto.getTextSummaryData(),"B3一键构造单条被评对象目标周期标准数据验证数据-D3-一键构造被评对象目标周期标准数据验证数据(公共)-资料文字概要不能为空",false);
      autoBuildEvaObjTarCycStaDataComRespDto = fwAppSystemTestDomainClient.autoBuildEvaObjTarCycStaDataCom(autoBuildEvaObjTarCycStaDataComReqDto).getData();
      
      
      
    
BffAutoBuildSingleEvaObjTarCycStaDataRespDto retData = new BffAutoBuildSingleEvaObjTarCycStaDataRespDto();
  
  

  
  
return retData;
  }
/**
   * B3一键构造单条虚拟组织成员验证数据(管理)[4529]
   * gen by moon at 9/12/2022, 10:16:36 PM
   */
    @Trace(operationName = "B3一键构造单条虚拟组织成员验证数据(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffAutoBuildSingleVirtualOrgMemRespDto autoBuildSingleVirtualOrgMem(BffAutoBuildSingleVirtualOrgMemReqDto reqDto){
      
       
       //步骤0: D3一键构造单个虚拟组织成员验证数据 - autoBuildSingleVirtualOrgMember
     AutoBuildSingleVirtualOrgMemberRespDto autoBuildSingleVirtualOrgMemberRespDto = null;
    AutoBuildSingleVirtualOrgMemberReqDto autoBuildSingleVirtualOrgMemberReqDto=new AutoBuildSingleVirtualOrgMemberReqDto();
  if(reqDto!=null){
      autoBuildSingleVirtualOrgMemberReqDto.setVirtualOrgMemberId(reqDto.getVirtualOrgMemberId());//sourceId:319929_1
autoBuildSingleVirtualOrgMemberReqDto.setVirtualOrgInductionRecordId(reqDto.getVirtualOrgInductionRecordId());//sourceId:319930_1
autoBuildSingleVirtualOrgMemberReqDto.setRoleCode(reqDto.getRoleCode());//sourceId:319931_1
autoBuildSingleVirtualOrgMemberReqDto.setVirtualOrganizationPosition(reqDto.getVirtualOrganizationPosition());//sourceId:319932_1
autoBuildSingleVirtualOrgMemberReqDto.setIsAdmin(reqDto.getIsAdmin());//sourceId:319933_1
autoBuildSingleVirtualOrgMemberReqDto.setIsDirectStakeholders(reqDto.getIsDirectStakeholders());//sourceId:319934_1
autoBuildSingleVirtualOrgMemberReqDto.setIsUpperLowerLevels(reqDto.getIsUpperLowerLevels());//sourceId:319935_1
autoBuildSingleVirtualOrgMemberReqDto.setIsPersonCharge(reqDto.getIsPersonCharge());//sourceId:319936_1
autoBuildSingleVirtualOrgMemberReqDto.setTableTypeCode(reqDto.getTableTypeCode());//sourceId:319937_1
autoBuildSingleVirtualOrgMemberReqDto.setEntityId(reqDto.getEntityId());//sourceId:319938_1
autoBuildSingleVirtualOrgMemberReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//sourceId:319939_1
    }
  
    /*D3一键构造单个虚拟组织成员验证数据[4527]   */
    
      autoBuildSingleVirtualOrgMemberRespDto = fwAppSystemTestDomainClient.autoBuildSingleVirtualOrgMember(autoBuildSingleVirtualOrgMemberReqDto).getData();
      
      
      
    
BffAutoBuildSingleVirtualOrgMemRespDto retData = new BffAutoBuildSingleVirtualOrgMemRespDto();
  
  

  
  
return retData;
  }
/**
   * B4-1-01修改单条被评对象目标周期标准数据(管理)[4538]
   * gen by moon at 9/10/2022, 10:04:58 PM
   */
    @Trace(operationName = "B4-1-01修改单条被评对象目标周期标准数据(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffUpdateSingleEvaObjTarCycStaDataRespDto updateSingleEvaObjTarCycStaData(BffUpdateSingleEvaObjTarCycStaDataReqDto reqDto){
      
       
       //步骤0: D4-1-01修改单条被评对象目标周期标准数据 - updateSingleEvaObjTarCycStaData
     UpdateSingleEvaObjTarCycStaDataRespDto updateSingleEvaObjTarCycStaDataRespDto = null;
    UpdateSingleEvaObjTarCycStaDataReqDto updateSingleEvaObjTarCycStaDataReqDto=new UpdateSingleEvaObjTarCycStaDataReqDto();
  if(reqDto!=null){
      updateSingleEvaObjTarCycStaDataReqDto.setPeriodId(reqDto.getPeriodId());//sourceId:320981_1
updateSingleEvaObjTarCycStaDataReqDto.setEntityId(reqDto.getEntityId());//sourceId:320983_1
updateSingleEvaObjTarCycStaDataReqDto.setUnit(reqDto.getUnit());//sourceId:320985_1
updateSingleEvaObjTarCycStaDataReqDto.setIsNewData(reqDto.getIsNewData());//sourceId:320986_1
updateSingleEvaObjTarCycStaDataReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//sourceId:320987_1
updateSingleEvaObjTarCycStaDataReqDto.setIsArchive(reqDto.getIsArchive());//sourceId:320988_1
updateSingleEvaObjTarCycStaDataReqDto.setActualValue(reqDto.getActualValue());//sourceId:320982_1
updateSingleEvaObjTarCycStaDataReqDto.setParentActualValue(reqDto.getParentActualValue());//sourceId:320984_1
updateSingleEvaObjTarCycStaDataReqDto.setProgressValue(reqDto.getProgressValue());//sourceId:320989_1
updateSingleEvaObjTarCycStaDataReqDto.setParentProgressValue(reqDto.getParentProgressValue());//sourceId:320990_1
updateSingleEvaObjTarCycStaDataReqDto.setReach(reqDto.getReach());//sourceId:320991_1
updateSingleEvaObjTarCycStaDataReqDto.setParentReach(reqDto.getParentReach());//sourceId:320992_1
updateSingleEvaObjTarCycStaDataReqDto.setRealTimeScore(reqDto.getRealTimeScore());//sourceId:320993_1
updateSingleEvaObjTarCycStaDataReqDto.setParentRealTimeScore(reqDto.getParentRealTimeScore());//sourceId:320994_1
updateSingleEvaObjTarCycStaDataReqDto.setProgressFromLastRatio(reqDto.getProgressFromLastRatio());//sourceId:320995_1
updateSingleEvaObjTarCycStaDataReqDto.setParentProgressFromLastRatio(reqDto.getParentProgressFromLastRatio());//sourceId:320996_1
updateSingleEvaObjTarCycStaDataReqDto.setActualFromLastTimeRatio(reqDto.getActualFromLastTimeRatio());//sourceId:320997_1
updateSingleEvaObjTarCycStaDataReqDto.setParentActualFromLastTimeRatio(reqDto.getParentActualFromLastTimeRatio());//sourceId:320998_1
    }
  
    /*D4-1-01修改单条被评对象目标周期标准数据[4535]   */
    Assert.isNull(updateSingleEvaObjTarCycStaDataReqDto.getPeriodId(),"B4-1-01修改单条被评对象目标周期标准数据(管理)-D4-1-01修改单条被评对象目标周期标准数据-周期ID不能为空",false);
Assert.isNull(updateSingleEvaObjTarCycStaDataReqDto.getEntityId(),"B4-1-01修改单条被评对象目标周期标准数据(管理)-D4-1-01修改单条被评对象目标周期标准数据-被评对象目标周期ID不能为空",false);
      updateSingleEvaObjTarCycStaDataRespDto = fwCalcSystemTestDomainClient.updateSingleEvaObjTarCycStaData(updateSingleEvaObjTarCycStaDataReqDto).getData();
      
      
      
    
BffUpdateSingleEvaObjTarCycStaDataRespDto retData = new BffUpdateSingleEvaObjTarCycStaDataRespDto();
  
  

  
  
return retData;
  }
/**
   * B3一键构造父子状态测试验证数据[4487]
   * gen by moon at 9/12/2022, 10:16:22 PM
   */
    @Trace(operationName = "B3一键构造父子状态测试验证数据")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffAutoBuildAssistNnodeStatusTestRespDto autoBuildAssistNnodeStatusTest(BffAutoBuildAssistNnodeStatusTestReqDto reqDto){
      
       
       //步骤0: D3-构造父子状态测试验证数据 - buildAssistNnodeStatusTest
     BuildAssistNnodeStatusTestRespDto buildAssistNnodeStatusTestRespDto = null;
    BuildAssistNnodeStatusTestReqDto buildAssistNnodeStatusTestReqDto=new BuildAssistNnodeStatusTestReqDto();
  if(reqDto!=null){
      buildAssistNnodeStatusTestReqDto.setAssistNodeTypeCode(reqDto.getAssistNodeTypeCode());//sourceId:313763_1
buildAssistNnodeStatusTestReqDto.setAssistNodeTypeObjectId(reqDto.getAssistNodeTypeObjectId());//sourceId:313764_1
buildAssistNnodeStatusTestReqDto.setAssistNodeTypeObjectCode(reqDto.getAssistNodeTypeObjectCode());//sourceId:313765_1
buildAssistNnodeStatusTestReqDto.setObjectTypeCode(reqDto.getObjectTypeCode());//sourceId:313766_1
buildAssistNnodeStatusTestReqDto.setObjectId(reqDto.getObjectId());//sourceId:313767_1
buildAssistNnodeStatusTestReqDto.setUpdateAssistNodeStatusId(reqDto.getUpdateAssistNodeStatusId());//sourceId:313768_1
buildAssistNnodeStatusTestReqDto.setNextNodeNum(reqDto.getNextNodeNum());//sourceId:313769_1
buildAssistNnodeStatusTestReqDto.setNextNodeDoneNum(reqDto.getNextNodeDoneNum());//sourceId:313770_1
buildAssistNnodeStatusTestReqDto.setDisplayStatus(reqDto.getDisplayStatus());//sourceId:313771_1
buildAssistNnodeStatusTestReqDto.setIsComplete(reqDto.getIsComplete());//sourceId:313772_1
buildAssistNnodeStatusTestReqDto.setCurrentLevelComplete(reqDto.getCurrentLevelComplete());//sourceId:313773_1
buildAssistNnodeStatusTestReqDto.setNextLevelComplete(reqDto.getNextLevelComplete());//sourceId:313774_1
buildAssistNnodeStatusTestReqDto.setCreateInductionId(reqDto.getCreateInductionId());//sourceId:313775_1
buildAssistNnodeStatusTestReqDto.setSpaceId(reqDto.getSpaceId());//sourceId:313776_1
buildAssistNnodeStatusTestReqDto.setAppId(reqDto.getAppId());//sourceId:313777_1
    }
  
    /*D3-构造父子状态测试验证数据[4486]   */
    Assert.isNull(buildAssistNnodeStatusTestReqDto.getCreateInductionId(),"B3一键构造父子状态测试验证数据-D3-构造父子状态测试验证数据-创建人就职记录ID 不能为空",false);
Assert.isNull(buildAssistNnodeStatusTestReqDto.getSpaceId(),"B3一键构造父子状态测试验证数据-D3-构造父子状态测试验证数据-创建于空间ID不能为空",false);
Assert.isNull(buildAssistNnodeStatusTestReqDto.getAppId(),"B3一键构造父子状态测试验证数据-D3-构造父子状态测试验证数据-创建于联盟应用ID不能为空",false);
      buildAssistNnodeStatusTestRespDto = fwAppSystemTestDomainClient.buildAssistNnodeStatusTest(buildAssistNnodeStatusTestReqDto).getData();
      
      
      
    
BffAutoBuildAssistNnodeStatusTestRespDto retData = new BffAutoBuildAssistNnodeStatusTestRespDto();
  
  

  
  
return retData;
  }
/**
   * B3一键构造单条批次验证数据(管理)[4497]
   * gen by moon at 9/12/2022, 10:16:30 PM
   */
    @Trace(operationName = "B3一键构造单条批次验证数据(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffAutoBuildSingleBatchRespDto autoBuildSingleBatch(BffAutoBuildSingleBatchReqDto reqDto){
      
       
       BuildSingleBatchComRespDto buildSingleBatchComRespDto_1 =null;
//步骤0: D3-13构造单条批次验证数据(公共) - buildSingleBatchCom
     BuildSingleBatchComRespDto buildSingleBatchComRespDto = null;
    BuildSingleBatchComReqDto buildSingleBatchComReqDto=new BuildSingleBatchComReqDto();
  if(reqDto!=null){
      buildSingleBatchComReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//sourceId:315216_1
buildSingleBatchComReqDto.setIsFirst(reqDto.getIsFirst());//sourceId:315218_1
buildSingleBatchComReqDto.setBatchName(reqDto.getBatchName());//sourceId:315217_1
buildSingleBatchComReqDto.setPurposeTypeCode(reqDto.getPurposeTypeCode());//sourceId:315219_1
buildSingleBatchComReqDto.setAscriptionObjectId(reqDto.getAscriptionObjectId());//sourceId:315220_1
buildSingleBatchComReqDto.setBatchSetObjectType(reqDto.getBatchSetObjectType());//sourceId:315221_1
buildSingleBatchComReqDto.setCurrentManageObjectType(reqDto.getCurrentManageObjectType());//sourceId:315222_1
buildSingleBatchComReqDto.setHistoricalArchiveBatchName(reqDto.getHistoricalArchiveBatchName());//sourceId:315228_1
buildSingleBatchComReqDto.setArchivngType(reqDto.getArchivngType());//sourceId:315224_1
    }
  
    /*D3-13构造单条批次验证数据(公共)[4251]   */
    Assert.isNull(buildSingleBatchComReqDto.getPurposeTypeCode(),"B3一键构造单条批次验证数据(管理)-D3-13构造单条批次验证数据(公共)-用途类型编码不能为空",false);
Assert.isNull(buildSingleBatchComReqDto.getAscriptionObjectId(),"B3一键构造单条批次验证数据(管理)-D3-13构造单条批次验证数据(公共)-归属对象ID不能为空",false);
Assert.isNull(buildSingleBatchComReqDto.getBatchSetObjectType(),"B3一键构造单条批次验证数据(管理)-D3-13构造单条批次验证数据(公共)-批次设置对象类型不能为空",false);
Assert.isNull(buildSingleBatchComReqDto.getCurrentManageObjectType(),"B3一键构造单条批次验证数据(管理)-D3-13构造单条批次验证数据(公共)-当前管理对象类型不能为空",false);
      buildSingleBatchComRespDto = fwAppSystemTestDomainClient.buildSingleBatchCom(buildSingleBatchComReqDto).getData();
      
      
      buildSingleBatchComRespDto_1 = buildSingleBatchComRespDto;
    
BffAutoBuildSingleBatchRespDto retData = new BffAutoBuildSingleBatchRespDto();
  if(buildSingleBatchComRespDto_1!=null){
      retData.setBatchCode(buildSingleBatchComRespDto_1.getBatchCode());//sourceId:322774_1
retData.setPreviousBatchCode(buildSingleBatchComRespDto_1.getPreviousBatchCode());//sourceId:322775_1
retData.setBatchRelatedSetId(buildSingleBatchComRespDto_1.getBatchRelatedSetId());//sourceId:322776_1
    }
  

  
  
return retData;
  }
/**
   * B3-3修改评价模板规划类型标准数据[4554]
   * gen by moon at 9/14/2022, 12:27:17 AM
   */
    @Trace(operationName = "B3-3修改评价模板规划类型标准数据")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffUpdateEvaTempTypeEtcRespDto updateEvaTempTypeEtc(BffUpdateEvaTempTypeEtcReqDto reqDto){
      
       
       //步骤0: D3-3修改评价模板规划类型标准数据 - updateEvaTempTypeEtc
     UpdateEvaTempTypeEtcRespDto updateEvaTempTypeEtcRespDto = null;
    UpdateEvaTempTypeEtcReqDto updateEvaTempTypeEtcReqDto=new UpdateEvaTempTypeEtcReqDto();
  if(reqDto!=null){
      updateEvaTempTypeEtcReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//sourceId:324309_1
updateEvaTempTypeEtcReqDto.setConfSchemeCode(reqDto.getConfSchemeCode());//sourceId:324311_1
updateEvaTempTypeEtcReqDto.setEvaluationTemplateTypeCode(reqDto.getEvaluationTemplateTypeCode());//sourceId:324312_1
updateEvaTempTypeEtcReqDto.setTargetPlanTempSubtype(reqDto.getTargetPlanTempSubtype());//sourceId:324313_1
updateEvaTempTypeEtcReqDto.setEvaluationSubjectTypeCode(reqDto.getEvaluationSubjectTypeCode());//sourceId:324314_1
updateEvaTempTypeEtcReqDto.setPlanningType(reqDto.getPlanningType());//sourceId:324315_1
updateEvaTempTypeEtcReqDto.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//sourceId:324310_1
    }
  
    /*D3-3修改评价模板规划类型标准数据[4555]   */
    Assert.isNull(updateEvaTempTypeEtcReqDto.getEvaluationTemplateId(),"B3-3修改评价模板规划类型标准数据-D3-3修改评价模板规划类型标准数据-评价模板ID不能为空",false);
      updateEvaTempTypeEtcRespDto = fwAppSystemTestDomainClient.updateEvaTempTypeEtc(updateEvaTempTypeEtcReqDto).getData();
      
      
      
    
BffUpdateEvaTempTypeEtcRespDto retData = new BffUpdateEvaTempTypeEtcRespDto();
  
  

  
  
return retData;
  }
/**
   * B3执行被评对象目标周期测试数据[4565]
   * gen by moon at 9/15/2022, 9:51:25 PM
   */
    @Trace(operationName = "B3执行被评对象目标周期测试数据")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffImplementEvaObjTarCycTestDataRespDto implementEvaObjTarCycTestData(BffImplementEvaObjTarCycTestDataReqDto reqDto){
      
       
       BffImplementEvaObjTarCycTestDataRespDto retData = new BffImplementEvaObjTarCycTestDataRespDto();
  
  

  
  
return retData;
  }
/**
   * 【超危险】B1删除空间测试(管理)【超危险】[4871]
   * gen by moon at 10/16/2022, 11:33:16 AM
   */
    @Trace(operationName = "【超危险】B1删除空间测试(管理)【超危险】")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffDeleteSpaceTestDataRespDto deleteSpaceTestData(BffDeleteSpaceTestDataReqDto reqDto){
      
       
       //步骤0: D1删除空间测试 - deleteSpaceTestData
     DeleteSpaceTestDataRespDto deleteSpaceTestDataRespDto = null;
    DeleteSpaceTestDataReqDto deleteSpaceTestDataReqDto=new DeleteSpaceTestDataReqDto();
  if(reqDto!=null){
      deleteSpaceTestDataReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:380733_1
    }
  
    /*D1删除空间测试[4872]   */
    Assert.isNull(deleteSpaceTestDataReqDto.getSpaceId(),"【超危险】B1删除空间测试(管理)【超危险】-D1删除空间测试-空间ID不能为空",false);
      deleteSpaceTestDataRespDto = fwBaseSystemTestDomainClient.deleteSpaceTestData(deleteSpaceTestDataReqDto).getData();
      
      
      
    
BffDeleteSpaceTestDataRespDto retData = new BffDeleteSpaceTestDataRespDto();
  
  

  
  
return retData;
  }
/**
   * B3批量删部门目标任务树测试(管理)[5126]
   * gen by moon at 11/9/2022, 11:51:41 PM
   */
    @Trace(operationName = "B3批量删部门目标任务树测试(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffBatchDeleteDeptObjTreeTestDataRespDto batchDeleteDeptObjTreeTestData(BffBatchDeleteDeptObjTreeTestDataReqDto reqDto){
      
       
       //步骤0: D3删除部门目标任务树测试(公共) - deleteDeptObjTreeTestDataCom
     DeleteDeptObjTreeTestDataComRespDto deleteDeptObjTreeTestDataComRespDto = null;
    DeleteDeptObjTreeTestDataComReqDto deleteDeptObjTreeTestDataComReqDto=new DeleteDeptObjTreeTestDataComReqDto();
  if(reqDto!=null){
      deleteDeptObjTreeTestDataComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:419934_1
deleteDeptObjTreeTestDataComReqDto.setEvaObjTableTypeCode(reqDto.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:419935_1
deleteDeptObjTreeTestDataComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:419936_1
deleteDeptObjTreeTestDataComReqDto.setTreeTypeCode(reqDto.getTreeTypeCode());//SimpleFieldAssign//sourceId:419937_1
deleteDeptObjTreeTestDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:427535_1
    }
  
    /*D3删除部门目标任务树测试(公共)[5123]   */
    Assert.isNull(deleteDeptObjTreeTestDataComReqDto.getEvaObjEntityId(),"B3批量删部门目标任务树测试(管理)-D3删除部门目标任务树测试(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(deleteDeptObjTreeTestDataComReqDto.getEvaObjTableTypeCode(),"B3批量删部门目标任务树测试(管理)-D3删除部门目标任务树测试(公共)-被评对象内容表类型编码不能为空",false);
Assert.isNull(deleteDeptObjTreeTestDataComReqDto.getEvaObjTypeCode(),"B3批量删部门目标任务树测试(管理)-D3删除部门目标任务树测试(公共)-被评对象类型编码不能为空",false);
Assert.isNull(deleteDeptObjTreeTestDataComReqDto.getTreeTypeCode(),"B3批量删部门目标任务树测试(管理)-D3删除部门目标任务树测试(公共)-树类型编码不能为空",false);
Assert.isNull(deleteDeptObjTreeTestDataComReqDto.getEvaluationTemplateId(),"B3批量删部门目标任务树测试(管理)-D3删除部门目标任务树测试(公共)-冗余评价模板ID不能为空",false);
      deleteDeptObjTreeTestDataComRespDto = fwAppSystemTestDomainClient.deleteDeptObjTreeTestDataCom(deleteDeptObjTreeTestDataComReqDto).getData();
      
      
      
    
BffBatchDeleteDeptObjTreeTestDataRespDto retData = new BffBatchDeleteDeptObjTreeTestDataRespDto();
  
  

  
  
return retData;
  }
/**
   * B3批量删部门下目标内容测试(管理)(公共)[5130]
   * gen by moon at 11/4/2022, 7:39:36 AM
   */
    @Trace(operationName = "B3批量删部门下目标内容测试(管理)(公共)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffBatchDeleteDeptTargetContentTestComRespDto batchDeleteDeptTargetContentTestCom(BffBatchDeleteDeptTargetContentTestComReqDto reqDto){
      
       
       //步骤0: D3批量删部门下目标内容测试(公共) - batchDeleteDeptTargetContentTestCom
     BatchDeleteDeptTargetContentTestComRespDto batchDeleteDeptTargetContentTestComRespDto = null;
    BatchDeleteDeptTargetContentTestComReqDto batchDeleteDeptTargetContentTestComReqDto=new BatchDeleteDeptTargetContentTestComReqDto();
  if(reqDto!=null){
      batchDeleteDeptTargetContentTestComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:419990_1
batchDeleteDeptTargetContentTestComReqDto.setEvaluationTemplateType(reqDto.getEvaluationTemplateType());//SimpleFieldAssign//sourceId:419991_1
batchDeleteDeptTargetContentTestComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:419992_1
    }
  
    /*D3批量删部门下目标内容测试(公共)[5127]   */
    Assert.isNull(batchDeleteDeptTargetContentTestComReqDto.getDeptId(),"B3批量删部门下目标内容测试(管理)(公共)-D3批量删部门下目标内容测试(公共)-虚拟组织下部门ID不能为空",false);
      batchDeleteDeptTargetContentTestComRespDto = fwAppSystemTestDomainClient.batchDeleteDeptTargetContentTestCom(batchDeleteDeptTargetContentTestComReqDto).getData();
      
      
      
    
BffBatchDeleteDeptTargetContentTestComRespDto retData = new BffBatchDeleteDeptTargetContentTestComRespDto();
  
  

  
  
return retData;
  }
/**
   * B3-执行更新状态检查项数据测试(管理）[5534]
   * gen by moon at 12/27/2022, 9:01:17 PM
   */
    @Trace(operationName = "B3-执行更新状态检查项数据测试(管理）")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffImplementUpdateStatusCheckItemDataRespDto implementUpdateStatusCheckItemData(BffImplementUpdateStatusCheckItemDataReqDto reqDto){


       //步骤0: D3-执行更新状态检查项数据测试 - implementUpdateStatusCheckItemData
     ImplementUpdateStatusCheckItemDataRespDto implementUpdateStatusCheckItemDataRespDto = null;
    ImplementUpdateStatusCheckItemDataReqDto implementUpdateStatusCheckItemDataReqDto=new ImplementUpdateStatusCheckItemDataReqDto();
  if(reqDto!=null){
      implementUpdateStatusCheckItemDataReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:550404_1
    }

    /*D3-执行更新状态检查项数据测试[5535]   */
    Assert.isNull(implementUpdateStatusCheckItemDataReqDto.getSpaceId(),"B3-执行更新状态检查项数据测试(管理）-D3-执行更新状态检查项数据测试-创建于空间ID不能为空",false);
      implementUpdateStatusCheckItemDataRespDto = fwAppSystemTestDomainClient.implementUpdateStatusCheckItemData(implementUpdateStatusCheckItemDataReqDto).getData();




BffImplementUpdateStatusCheckItemDataRespDto retData = new BffImplementUpdateStatusCheckItemDataRespDto();





return retData;
  }
/**
   * B3-批量更新模板下父子状态检查项等测试(平台）[5564]
   * gen by moon at 12/30/2022, 6:41:07 PM
   */
    @Trace(operationName = "B3-批量更新模板下父子状态检查项等测试(平台）")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffBatchRefreshAssistNnodeStatusEtcTestRespDto batchRefreshAssistNnodeStatusEtcTest(BffBatchRefreshAssistNnodeStatusEtcTestReqDto reqDto){


       //步骤0: D3-执行更新状态检查项数据测试(公共) - implementUpdateStatusCheckItemDataCom
     ImplementUpdateStatusCheckItemDataComRespDto implementUpdateStatusCheckItemDataComRespDto = null;
    ImplementUpdateStatusCheckItemDataComReqDto implementUpdateStatusCheckItemDataComReqDto=new ImplementUpdateStatusCheckItemDataComReqDto();
  if(reqDto!=null){
      implementUpdateStatusCheckItemDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:556847_1
    }

    /*D3-执行更新状态检查项数据测试(公共)[5560]   */
    Assert.isNull(implementUpdateStatusCheckItemDataComReqDto.getEvaluationTemplateId(),"B3-批量更新模板下父子状态检查项等测试(平台）-D3-执行更新状态检查项数据测试(公共)-冗余评价模板ID不能为空",false);
      implementUpdateStatusCheckItemDataComRespDto = fwAppSystemTestDomainClient.implementUpdateStatusCheckItemDataCom(implementUpdateStatusCheckItemDataComReqDto).getData();




//步骤1: D3-执行更新仪表盘数据测试(公共) - implementUpdateAssistCheckPanelTestCom
     ImplementUpdateAssistCheckPanelTestComRespDto implementUpdateAssistCheckPanelTestComRespDto = null;
    ImplementUpdateAssistCheckPanelTestComReqDto implementUpdateAssistCheckPanelTestComReqDto=new ImplementUpdateAssistCheckPanelTestComReqDto();
  if(reqDto!=null){
      implementUpdateAssistCheckPanelTestComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:556846_1
    }

    /*D3-执行更新仪表盘数据测试(公共)[5553]   */
    Assert.isNull(implementUpdateAssistCheckPanelTestComReqDto.getEvaluationTemplateId(),"B3-批量更新模板下父子状态检查项等测试(平台）-D3-执行更新仪表盘数据测试(公共)-冗余评价模板ID不能为空",false);
      implementUpdateAssistCheckPanelTestComRespDto = fwAppSystemTestDomainClient.implementUpdateAssistCheckPanelTestCom(implementUpdateAssistCheckPanelTestComReqDto).getData();




//步骤2: D3-执行更新父子状态数据测试(公共) - implementUpdateAssistNnodeStatusTestCom
     ImplementUpdateAssistNnodeStatusTestComRespDto implementUpdateAssistNnodeStatusTestComRespDto = null;
    ImplementUpdateAssistNnodeStatusTestComReqDto implementUpdateAssistNnodeStatusTestComReqDto=new ImplementUpdateAssistNnodeStatusTestComReqDto();
  if(reqDto!=null){
      implementUpdateAssistNnodeStatusTestComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:556845_1
    }

    /*D3-执行更新父子状态数据测试(公共)[5556]   */
    Assert.isNull(implementUpdateAssistNnodeStatusTestComReqDto.getEvaluationTemplateId(),"B3-批量更新模板下父子状态检查项等测试(平台）-D3-执行更新父子状态数据测试(公共)-冗余评价模板ID不能为空",false);
      implementUpdateAssistNnodeStatusTestComRespDto = fwAppSystemTestDomainClient.implementUpdateAssistNnodeStatusTestCom(implementUpdateAssistNnodeStatusTestComReqDto).getData();




BffBatchRefreshAssistNnodeStatusEtcTestRespDto retData = new BffBatchRefreshAssistNnodeStatusEtcTestRespDto();





return retData;
  }
/**
   * B3执行修正模板下内容上级父子状态数据测试(平台）[5956]
   * gen by moon at 2/19/2023, 4:50:53 PM
   */
    @Trace(operationName = "B3执行修正模板下内容上级父子状态数据测试(平台）")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffImplementCorrectionTempParentNodeStatusTestRespDto implementCorrectionTempParentNodeStatusTest(BffImplementCorrectionTempParentNodeStatusTestReqDto reqDto){


       //步骤0: D3执行修正模板下内容上级父子状态数据测试 - implementCorrectionTempParentNodeStatusTest
     ImplementCorrectionTempParentNodeStatusTestRespDto implementCorrectionTempParentNodeStatusTestRespDto = null;
    ImplementCorrectionTempParentNodeStatusTestReqDto implementCorrectionTempParentNodeStatusTestReqDto=new ImplementCorrectionTempParentNodeStatusTestReqDto();
  if(reqDto!=null){
      implementCorrectionTempParentNodeStatusTestReqDto.setComCode(reqDto.getComCode());//SimpleFieldAssign//sourceId:690029_1
implementCorrectionTempParentNodeStatusTestReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:690027_1
implementCorrectionTempParentNodeStatusTestReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:690028_1
    }

    /*D3执行修正模板下内容上级父子状态数据测试[5953]   */
    Assert.isNull(implementCorrectionTempParentNodeStatusTestReqDto.getComCode(),"B3执行修正模板下内容上级父子状态数据测试(平台）-D3执行修正模板下内容上级父子状态数据测试-通用编码标识不能为空",false);
Assert.isNull(implementCorrectionTempParentNodeStatusTestReqDto.getEvaluationTemplateId(),"B3执行修正模板下内容上级父子状态数据测试(平台）-D3执行修正模板下内容上级父子状态数据测试-冗余评价模板ID不能为空",false);
Assert.isNull(implementCorrectionTempParentNodeStatusTestReqDto.getSpaceId(),"B3执行修正模板下内容上级父子状态数据测试(平台）-D3执行修正模板下内容上级父子状态数据测试-创建于空间ID不能为空",false);
      implementCorrectionTempParentNodeStatusTestRespDto = fwAppSystemTestDomainClient.implementCorrectionTempParentNodeStatusTest(implementCorrectionTempParentNodeStatusTestReqDto).getData();




BffImplementCorrectionTempParentNodeStatusTestRespDto retData = new BffImplementCorrectionTempParentNodeStatusTestRespDto();





return retData;
  }
/**
   * B3执行目标内容检查项状态等三大件刷新测试(平台）[6133]
   * gen by moon at 4/5/2023, 5:50:16 PM
   */
    @Trace(operationName = "B3执行目标内容检查项状态等三大件刷新测试(平台）")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffImplementTargetContCheckItemThreeTestRespDto implementTargetContCheckItemThreeTest(BffImplementTargetContCheckItemThreeTestReqDto reqDto){


       //步骤0: D3执行目标内容检查项状态等三大件刷新测试(公共) - implementTargetContCheckItemThreeTestCom
     ImplementTargetContCheckItemThreeTestComRespDto implementTargetContCheckItemThreeTestComRespDto = null;
    ImplementTargetContCheckItemThreeTestComReqDto implementTargetContCheckItemThreeTestComReqDto=new ImplementTargetContCheckItemThreeTestComReqDto();
  if(reqDto!=null){
      implementTargetContCheckItemThreeTestComReqDto.setEvaObjTargetCycleCode(reqDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:773152_1
implementTargetContCheckItemThreeTestComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:773153_1
implementTargetContCheckItemThreeTestComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:811631_1
//implementTargetContCheckItemThreeTestComReqDto.setUpdateEvaObjTypeCode(reqDto.getUpdateEvaObjTypeCode());//SimpleFieldAssign//sourceId:811632_1
implementTargetContCheckItemThreeTestComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:773151_1
implementTargetContCheckItemThreeTestComReqDto.setCreateInductionId(reqDto.getCreateInductionId());//SimpleFieldAssign//sourceId:773155_1
implementTargetContCheckItemThreeTestComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:773156_1
implementTargetContCheckItemThreeTestComReqDto.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:773157_1
    }

    /*D3执行目标内容检查项状态等三大件刷新测试(公共)[6130]   */
    Assert.isNull(implementTargetContCheckItemThreeTestComReqDto.getEvaObjTargetCycleCode(),"B3执行目标内容检查项状态等三大件刷新测试(平台）-D3执行目标内容检查项状态等三大件刷新测试(公共)-被评对象目标周期标识不能为空",false);
Assert.isNull(implementTargetContCheckItemThreeTestComReqDto.getEvaObjEntityId(),"B3执行目标内容检查项状态等三大件刷新测试(平台）-D3执行目标内容检查项状态等三大件刷新测试(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(implementTargetContCheckItemThreeTestComReqDto.getEvaObjTypeCode(),"B3执行目标内容检查项状态等三大件刷新测试(平台）-D3执行目标内容检查项状态等三大件刷新测试(公共)-被评对象类型编码不能为空",false);
Assert.isNull(implementTargetContCheckItemThreeTestComReqDto.getEvaluationTemplateId(),"B3执行目标内容检查项状态等三大件刷新测试(平台）-D3执行目标内容检查项状态等三大件刷新测试(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementTargetContCheckItemThreeTestComReqDto.getCreateInductionId(),"B3执行目标内容检查项状态等三大件刷新测试(平台）-D3执行目标内容检查项状态等三大件刷新测试(公共)-创建人就职记录ID 不能为空",false);
Assert.isNull(implementTargetContCheckItemThreeTestComReqDto.getSpaceId(),"B3执行目标内容检查项状态等三大件刷新测试(平台）-D3执行目标内容检查项状态等三大件刷新测试(公共)-创建于空间ID不能为空",false);
Assert.isNull(implementTargetContCheckItemThreeTestComReqDto.getAppId(),"B3执行目标内容检查项状态等三大件刷新测试(平台）-D3执行目标内容检查项状态等三大件刷新测试(公共)-创建于联盟应用ID不能为空",false);
      implementTargetContCheckItemThreeTestComRespDto = fwAppSystemTestDomainClient.implementTargetContCheckItemThreeTestCom(implementTargetContCheckItemThreeTestComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;







BffImplementTargetContCheckItemThreeTestRespDto retData = new BffImplementTargetContCheckItemThreeTestRespDto();





return retData;
  }
/**
   * B3执行清理目标内容垃圾数据测试[6231]
   * gen by moon at 4/7/2023, 3:03:56 PM
   */
    @Trace(operationName = "B3执行清理目标内容垃圾数据测试")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffImplementCleanTargetContRubbishDataRespDto implementCleanTargetContRubbishData(BffImplementCleanTargetContRubbishDataReqDto reqDto){


       //步骤0: D3执行清理目标内容垃圾数据测试(公共) - implementCleanTargetContRubbishDataCom
     ImplementCleanTargetContRubbishDataComRespDto implementCleanTargetContRubbishDataComRespDto = null;
    ImplementCleanTargetContRubbishDataComReqDto implementCleanTargetContRubbishDataComReqDto=new ImplementCleanTargetContRubbishDataComReqDto();
  if(reqDto!=null){
      implementCleanTargetContRubbishDataComReqDto.setEvaObjTargetCycleCode(reqDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:813655_1
implementCleanTargetContRubbishDataComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:813656_1
implementCleanTargetContRubbishDataComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:813657_1
implementCleanTargetContRubbishDataComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:813658_1
implementCleanTargetContRubbishDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:813659_1
implementCleanTargetContRubbishDataComReqDto.setCreateInductionId(reqDto.getCreateInductionId());//SimpleFieldAssign//sourceId:813660_1
implementCleanTargetContRubbishDataComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:813661_1
implementCleanTargetContRubbishDataComReqDto.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:813662_1
    }

    /*D3执行清理目标内容垃圾数据测试(公共)[6219]   */
    Assert.isNull(implementCleanTargetContRubbishDataComReqDto.getEvaObjTargetCycleCode(),"B3执行清理目标内容垃圾数据测试-D3执行清理目标内容垃圾数据测试(公共)-被评对象目标周期标识不能为空",false);
Assert.isNull(implementCleanTargetContRubbishDataComReqDto.getEvaObjEntityId(),"B3执行清理目标内容垃圾数据测试-D3执行清理目标内容垃圾数据测试(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(implementCleanTargetContRubbishDataComReqDto.getEvaObjTypeCode(),"B3执行清理目标内容垃圾数据测试-D3执行清理目标内容垃圾数据测试(公共)-被评对象类型编码不能为空",false);
Assert.isNull(implementCleanTargetContRubbishDataComReqDto.getTargetCycleContentId(),"B3执行清理目标内容垃圾数据测试-D3执行清理目标内容垃圾数据测试(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementCleanTargetContRubbishDataComReqDto.getEvaluationTemplateId(),"B3执行清理目标内容垃圾数据测试-D3执行清理目标内容垃圾数据测试(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementCleanTargetContRubbishDataComReqDto.getCreateInductionId(),"B3执行清理目标内容垃圾数据测试-D3执行清理目标内容垃圾数据测试(公共)-创建人就职记录ID 不能为空",false);
Assert.isNull(implementCleanTargetContRubbishDataComReqDto.getSpaceId(),"B3执行清理目标内容垃圾数据测试-D3执行清理目标内容垃圾数据测试(公共)-创建于空间ID不能为空",false);
Assert.isNull(implementCleanTargetContRubbishDataComReqDto.getAppId(),"B3执行清理目标内容垃圾数据测试-D3执行清理目标内容垃圾数据测试(公共)-创建于联盟应用ID不能为空",false);
      implementCleanTargetContRubbishDataComRespDto = fwAppSystemTestDomainClient.implementCleanTargetContRubbishDataCom(implementCleanTargetContRubbishDataComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




BffImplementCleanTargetContRubbishDataRespDto retData = new BffImplementCleanTargetContRubbishDataRespDto();





return retData;
  }
/**
   * B3执行指标负责人情况分析测试[6232]
   * gen by moon at 4/7/2023, 3:04:04 PM
   */
    @Trace(operationName = "B3执行指标负责人情况分析测试")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffImplementObjtivePrincipalAnalyseRespDto implementObjtivePrincipalAnalyse(BffImplementObjtivePrincipalAnalyseReqDto reqDto){


       //步骤0: D3执行指标负责人情况分析测试(公共) - implementObjtivePrincipalAnalyseCom
     ImplementObjtivePrincipalAnalyseComRespDto implementObjtivePrincipalAnalyseComRespDto = null;
    ImplementObjtivePrincipalAnalyseComReqDto implementObjtivePrincipalAnalyseComReqDto=new ImplementObjtivePrincipalAnalyseComReqDto();
  if(reqDto!=null){
      implementObjtivePrincipalAnalyseComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:813674_1
implementObjtivePrincipalAnalyseComReqDto.setCreateInductionId(reqDto.getCreateInductionId());//SimpleFieldAssign//sourceId:813671_1
implementObjtivePrincipalAnalyseComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:813672_1
implementObjtivePrincipalAnalyseComReqDto.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:813673_1
    }

    /*D3执行指标负责人情况分析测试(公共)[6224]   */
    Assert.isNull(implementObjtivePrincipalAnalyseComReqDto.getEvaluationTemplateId(),"B3执行指标负责人情况分析测试-D3执行指标负责人情况分析测试(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementObjtivePrincipalAnalyseComReqDto.getCreateInductionId(),"B3执行指标负责人情况分析测试-D3执行指标负责人情况分析测试(公共)-创建人就职记录ID 不能为空",false);
Assert.isNull(implementObjtivePrincipalAnalyseComReqDto.getSpaceId(),"B3执行指标负责人情况分析测试-D3执行指标负责人情况分析测试(公共)-创建于空间ID不能为空",false);
Assert.isNull(implementObjtivePrincipalAnalyseComReqDto.getAppId(),"B3执行指标负责人情况分析测试-D3执行指标负责人情况分析测试(公共)-创建于联盟应用ID不能为空",false);
      implementObjtivePrincipalAnalyseComRespDto = fwAppSystemTestDomainClient.implementObjtivePrincipalAnalyseCom(implementObjtivePrincipalAnalyseComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




BffImplementObjtivePrincipalAnalyseRespDto retData = new BffImplementObjtivePrincipalAnalyseRespDto();





return retData;
  }
/**
   * B3执行循环初始化部门OKR根节点检查项状态测试[6233]
   * gen by moon at 4/7/2023, 3:04:13 PM
   */
    @Trace(operationName = "B3执行循环初始化部门OKR根节点检查项状态测试")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffImplementLoopInitializeDeptOkrRootNodeCheckitemStateRespDto implementLoopInitializeDeptOkrRootNodeCheckitemState(BffImplementLoopInitializeDeptOkrRootNodeCheckitemStateReqDto reqDto){


       //步骤0: D3执行循环初始化部门OKR根节点检查项状态测试(公共) - implementLoopInitializeDeptOkrRootNodeCheckitemStateCom
     ImplementLoopInitializeDeptOkrRootNodeCheckitemStateComRespDto implementLoopInitializeDeptOkrRootNodeCheckitemStateComRespDto = null;
    ImplementLoopInitializeDeptOkrRootNodeCheckitemStateComReqDto implementLoopInitializeDeptOkrRootNodeCheckitemStateComReqDto=new ImplementLoopInitializeDeptOkrRootNodeCheckitemStateComReqDto();
  if(reqDto!=null){
      implementLoopInitializeDeptOkrRootNodeCheckitemStateComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:813680_1
implementLoopInitializeDeptOkrRootNodeCheckitemStateComReqDto.setCreateInductionId(reqDto.getCreateInductionId());//SimpleFieldAssign//sourceId:813681_1
implementLoopInitializeDeptOkrRootNodeCheckitemStateComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:813682_1
implementLoopInitializeDeptOkrRootNodeCheckitemStateComReqDto.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:813683_1
    }

    /*D3执行循环初始化部门OKR根节点检查项状态测试(公共)[6227]   */
    Assert.isNull(implementLoopInitializeDeptOkrRootNodeCheckitemStateComReqDto.getEvaluationTemplateId(),"B3执行循环初始化部门OKR根节点检查项状态测试-D3执行循环初始化部门OKR根节点检查项状态测试(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementLoopInitializeDeptOkrRootNodeCheckitemStateComReqDto.getCreateInductionId(),"B3执行循环初始化部门OKR根节点检查项状态测试-D3执行循环初始化部门OKR根节点检查项状态测试(公共)-创建人就职记录ID 不能为空",false);
Assert.isNull(implementLoopInitializeDeptOkrRootNodeCheckitemStateComReqDto.getSpaceId(),"B3执行循环初始化部门OKR根节点检查项状态测试-D3执行循环初始化部门OKR根节点检查项状态测试(公共)-创建于空间ID不能为空",false);
Assert.isNull(implementLoopInitializeDeptOkrRootNodeCheckitemStateComReqDto.getAppId(),"B3执行循环初始化部门OKR根节点检查项状态测试-D3执行循环初始化部门OKR根节点检查项状态测试(公共)-创建于联盟应用ID不能为空",false);
      implementLoopInitializeDeptOkrRootNodeCheckitemStateComRespDto = fwAppSystemTestDomainClient.implementLoopInitializeDeptOkrRootNodeCheckitemStateCom(implementLoopInitializeDeptOkrRootNodeCheckitemStateComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




BffImplementLoopInitializeDeptOkrRootNodeCheckitemStateRespDto retData = new BffImplementLoopInitializeDeptOkrRootNodeCheckitemStateRespDto();





return retData;
  }
/**
   * B3执行补偿指标其他三棵树节点[6234]
   * gen by moon at 4/7/2023, 3:04:21 PM
   */
    @Trace(operationName = "B3执行补偿指标其他三棵树节点")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffImplementCompensateObjtiveOtherTreeNodeRespDto implementCompensateObjtiveOtherTreeNode(BffImplementCompensateObjtiveOtherTreeNodeReqDto reqDto){


       //步骤0: D3执行补偿指标其他三棵树节点测试(公共) - implementCompensateObjtiveOtherTreeNodeCom
     ImplementCompensateObjtiveOtherTreeNodeComRespDto implementCompensateObjtiveOtherTreeNodeComRespDto = null;
    ImplementCompensateObjtiveOtherTreeNodeComReqDto implementCompensateObjtiveOtherTreeNodeComReqDto=new ImplementCompensateObjtiveOtherTreeNodeComReqDto();
  if(reqDto!=null){
      implementCompensateObjtiveOtherTreeNodeComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:813688_1
implementCompensateObjtiveOtherTreeNodeComReqDto.setCreateInductionId(reqDto.getCreateInductionId());//SimpleFieldAssign//sourceId:813689_1
implementCompensateObjtiveOtherTreeNodeComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:813690_1
implementCompensateObjtiveOtherTreeNodeComReqDto.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:813691_1
    }

    /*D3执行补偿指标其他三棵树节点测试(公共)[6220]   */
    Assert.isNull(implementCompensateObjtiveOtherTreeNodeComReqDto.getEvaluationTemplateId(),"B3执行补偿指标其他三棵树节点-D3执行补偿指标其他三棵树节点测试(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementCompensateObjtiveOtherTreeNodeComReqDto.getCreateInductionId(),"B3执行补偿指标其他三棵树节点-D3执行补偿指标其他三棵树节点测试(公共)-创建人就职记录ID 不能为空",false);
Assert.isNull(implementCompensateObjtiveOtherTreeNodeComReqDto.getSpaceId(),"B3执行补偿指标其他三棵树节点-D3执行补偿指标其他三棵树节点测试(公共)-创建于空间ID不能为空",false);
Assert.isNull(implementCompensateObjtiveOtherTreeNodeComReqDto.getAppId(),"B3执行补偿指标其他三棵树节点-D3执行补偿指标其他三棵树节点测试(公共)-创建于联盟应用ID不能为空",false);
      implementCompensateObjtiveOtherTreeNodeComRespDto = fwAppSystemTestDomainClient.implementCompensateObjtiveOtherTreeNodeCom(implementCompensateObjtiveOtherTreeNodeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




BffImplementCompensateObjtiveOtherTreeNodeRespDto retData = new BffImplementCompensateObjtiveOtherTreeNodeRespDto();





return retData;
  }
/**
   * B3执行部门目标任务书叶子父子状态刷新[6235]
   * gen by moon at 4/7/2023, 3:04:30 PM
   */
    @Trace(operationName = "B3执行部门目标任务书叶子父子状态刷新")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffImplementDeptTargetTaskLeafNodeStateRespDto implementDeptTargetTaskLeafNodeState(BffImplementDeptTargetTaskLeafNodeStateReqDto reqDto){


       //步骤0: D3执行部门目标任务书叶子父子状态刷新测试(公共) - implementDeptTargetTaskLeafNodeStateCom
     ImplementDeptTargetTaskLeafNodeStateComRespDto implementDeptTargetTaskLeafNodeStateComRespDto = null;
    ImplementDeptTargetTaskLeafNodeStateComReqDto implementDeptTargetTaskLeafNodeStateComReqDto=new ImplementDeptTargetTaskLeafNodeStateComReqDto();
  if(reqDto!=null){
      implementDeptTargetTaskLeafNodeStateComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:813700_1
implementDeptTargetTaskLeafNodeStateComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:813699_1
implementDeptTargetTaskLeafNodeStateComReqDto.setCreateInductionId(reqDto.getCreateInductionId());//SimpleFieldAssign//sourceId:813696_1
implementDeptTargetTaskLeafNodeStateComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:813697_1
implementDeptTargetTaskLeafNodeStateComReqDto.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:813698_1
    }

    /*D3执行部门目标任务书叶子父子状态刷新测试(公共)[6131]   */
    Assert.isNull(implementDeptTargetTaskLeafNodeStateComReqDto.getEvaObjEntityId(),"B3执行部门目标任务书叶子父子状态刷新-D3执行部门目标任务书叶子父子状态刷新测试(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(implementDeptTargetTaskLeafNodeStateComReqDto.getEvaluationTemplateId(),"B3执行部门目标任务书叶子父子状态刷新-D3执行部门目标任务书叶子父子状态刷新测试(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementDeptTargetTaskLeafNodeStateComReqDto.getCreateInductionId(),"B3执行部门目标任务书叶子父子状态刷新-D3执行部门目标任务书叶子父子状态刷新测试(公共)-创建人就职记录ID 不能为空",false);
Assert.isNull(implementDeptTargetTaskLeafNodeStateComReqDto.getSpaceId(),"B3执行部门目标任务书叶子父子状态刷新-D3执行部门目标任务书叶子父子状态刷新测试(公共)-创建于空间ID不能为空",false);
Assert.isNull(implementDeptTargetTaskLeafNodeStateComReqDto.getAppId(),"B3执行部门目标任务书叶子父子状态刷新-D3执行部门目标任务书叶子父子状态刷新测试(公共)-创建于联盟应用ID不能为空",false);
      implementDeptTargetTaskLeafNodeStateComRespDto = fwAppSystemTestDomainClient.implementDeptTargetTaskLeafNodeStateCom(implementDeptTargetTaskLeafNodeStateComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




BffImplementDeptTargetTaskLeafNodeStateRespDto retData = new BffImplementDeptTargetTaskLeafNodeStateRespDto();





return retData;
  }
/**
   * B3执行OKR树检查项状态三大件初始化测试[6236]
   * gen by moon at 4/7/2023, 3:04:39 PM
   */
    @Trace(operationName = "B3执行OKR树检查项状态三大件初始化测试")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffImplementOkrTreeCheckItemStateEtcInitializeEtcTestRespDto implementOkrTreeCheckItemStateEtcInitializeEtcTest(BffImplementOkrTreeCheckItemStateEtcInitializeEtcTestReqDto reqDto){


       //步骤0: D3执行OKR树检查项状态三大件初始化测试(公共) - implementOkrTreeCheckItemStateEtcInitializeEtcTestCom
     ImplementOkrTreeCheckItemStateEtcInitializeEtcTestComRespDto implementOkrTreeCheckItemStateEtcInitializeEtcTestComRespDto = null;
    ImplementOkrTreeCheckItemStateEtcInitializeEtcTestComReqDto implementOkrTreeCheckItemStateEtcInitializeEtcTestComReqDto=new ImplementOkrTreeCheckItemStateEtcInitializeEtcTestComReqDto();
  if(reqDto!=null){
      implementOkrTreeCheckItemStateEtcInitializeEtcTestComReqDto.setEvaObjTargetCycleCode(reqDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:813709_1
implementOkrTreeCheckItemStateEtcInitializeEtcTestComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:813708_1
implementOkrTreeCheckItemStateEtcInitializeEtcTestComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:813707_1
implementOkrTreeCheckItemStateEtcInitializeEtcTestComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:813706_1
    }

    /*D3执行OKR树检查项状态三大件初始化测试(公共)[6206]   */
    Assert.isNull(implementOkrTreeCheckItemStateEtcInitializeEtcTestComReqDto.getEvaObjTargetCycleCode(),"B3执行OKR树检查项状态三大件初始化测试-D3执行OKR树检查项状态三大件初始化测试(公共)-被评对象目标周期标识不能为空",false);
Assert.isNull(implementOkrTreeCheckItemStateEtcInitializeEtcTestComReqDto.getEvaObjEntityId(),"B3执行OKR树检查项状态三大件初始化测试-D3执行OKR树检查项状态三大件初始化测试(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(implementOkrTreeCheckItemStateEtcInitializeEtcTestComReqDto.getEvaObjTypeCode(),"B3执行OKR树检查项状态三大件初始化测试-D3执行OKR树检查项状态三大件初始化测试(公共)-被评对象类型编码不能为空",false);
Assert.isNull(implementOkrTreeCheckItemStateEtcInitializeEtcTestComReqDto.getEvaluationTemplateId(),"B3执行OKR树检查项状态三大件初始化测试-D3执行OKR树检查项状态三大件初始化测试(公共)-冗余评价模板ID不能为空",false);
      implementOkrTreeCheckItemStateEtcInitializeEtcTestComRespDto = fwAppSystemTestDomainClient.implementOkrTreeCheckItemStateEtcInitializeEtcTestCom(implementOkrTreeCheckItemStateEtcInitializeEtcTestComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




BffImplementOkrTreeCheckItemStateEtcInitializeEtcTestRespDto retData = new BffImplementOkrTreeCheckItemStateEtcInitializeEtcTestRespDto();





return retData;
  }
/**
   * B3执行循环初始化OKR树检查项状态等测试（平台）[6239]
   * gen by moon at 4/7/2023, 3:04:47 PM
   */
    @Trace(operationName = "B3执行循环初始化OKR树检查项状态等测试（平台）")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffImplementLoopInitializeOkrTreeCheckitemStateEtcRespDto implementLoopInitializeOkrTreeCheckitemStateEtc(BffImplementLoopInitializeOkrTreeCheckitemStateEtcReqDto reqDto){


       //步骤0: D3执行循环初始化OKR树检查项状态等测试(公共) - implementLoopInitializeOkrTreeCheckitemStateEtcCom
     ImplementLoopInitializeOkrTreeCheckitemStateEtcComRespDto implementLoopInitializeOkrTreeCheckitemStateEtcComRespDto = null;
    ImplementLoopInitializeOkrTreeCheckitemStateEtcComReqDto implementLoopInitializeOkrTreeCheckitemStateEtcComReqDto=new ImplementLoopInitializeOkrTreeCheckitemStateEtcComReqDto();
  if(reqDto!=null){
      implementLoopInitializeOkrTreeCheckitemStateEtcComReqDto.setEvaObjTargetCycleCode(reqDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:813718_1
implementLoopInitializeOkrTreeCheckitemStateEtcComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:813719_1
implementLoopInitializeOkrTreeCheckitemStateEtcComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:813720_1
implementLoopInitializeOkrTreeCheckitemStateEtcComReqDto.setCreateInductionId(reqDto.getCreateInductionId());//SimpleFieldAssign//sourceId:813721_1
implementLoopInitializeOkrTreeCheckitemStateEtcComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:813722_1
implementLoopInitializeOkrTreeCheckitemStateEtcComReqDto.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:813723_1
    }

    /*D3执行循环初始化OKR树检查项状态等测试(公共)[6226]   */
    Assert.isNull(implementLoopInitializeOkrTreeCheckitemStateEtcComReqDto.getEvaObjTargetCycleCode(),"B3执行循环初始化OKR树检查项状态等测试（平台）-D3执行循环初始化OKR树检查项状态等测试(公共)-被评对象目标周期标识不能为空",false);
Assert.isNull(implementLoopInitializeOkrTreeCheckitemStateEtcComReqDto.getEvaObjTypeCode(),"B3执行循环初始化OKR树检查项状态等测试（平台）-D3执行循环初始化OKR树检查项状态等测试(公共)-被评对象类型编码不能为空",false);
Assert.isNull(implementLoopInitializeOkrTreeCheckitemStateEtcComReqDto.getEvaluationTemplateId(),"B3执行循环初始化OKR树检查项状态等测试（平台）-D3执行循环初始化OKR树检查项状态等测试(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementLoopInitializeOkrTreeCheckitemStateEtcComReqDto.getCreateInductionId(),"B3执行循环初始化OKR树检查项状态等测试（平台）-D3执行循环初始化OKR树检查项状态等测试(公共)-创建人就职记录ID 不能为空",false);
Assert.isNull(implementLoopInitializeOkrTreeCheckitemStateEtcComReqDto.getSpaceId(),"B3执行循环初始化OKR树检查项状态等测试（平台）-D3执行循环初始化OKR树检查项状态等测试(公共)-创建于空间ID不能为空",false);
Assert.isNull(implementLoopInitializeOkrTreeCheckitemStateEtcComReqDto.getAppId(),"B3执行循环初始化OKR树检查项状态等测试（平台）-D3执行循环初始化OKR树检查项状态等测试(公共)-创建于联盟应用ID不能为空",false);
      implementLoopInitializeOkrTreeCheckitemStateEtcComRespDto = fwAppSystemTestDomainClient.implementLoopInitializeOkrTreeCheckitemStateEtcCom(implementLoopInitializeOkrTreeCheckitemStateEtcComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




BffImplementLoopInitializeOkrTreeCheckitemStateEtcRespDto retData = new BffImplementLoopInitializeOkrTreeCheckitemStateEtcRespDto();





return retData;
  }
/**
   * B3执行修正模板执行周期及汇报调度等测试(管理)[7691]
   * gen by moon at 11/4/2023, 3:59:41 PM
   */
    @Trace(operationName = "B3执行修正模板执行周期及汇报调度等测试(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffImplementAmendTempExeCycleAndReportDispatchEtcTestRespDto implementAmendTempExeCycleAndReportDispatchEtcTest(BffImplementAmendTempExeCycleAndReportDispatchEtcTestReqDto reqDto){


       //步骤0: D3执行修正模板执行周期及汇报调度等测试 - implementAmendTempExeCycleAndReportDispatchEtcTest
     ImplementAmendTempExeCycleAndReportDispatchEtcTestRespDto implementAmendTempExeCycleAndReportDispatchEtcTestRespDto = null;
    ImplementAmendTempExeCycleAndReportDispatchEtcTestReqDto implementAmendTempExeCycleAndReportDispatchEtcTestReqDto=new ImplementAmendTempExeCycleAndReportDispatchEtcTestReqDto();
  if(reqDto!=null){
      implementAmendTempExeCycleAndReportDispatchEtcTestReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1238616_1
implementAmendTempExeCycleAndReportDispatchEtcTestReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1238617_1
implementAmendTempExeCycleAndReportDispatchEtcTestReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1238618_1
implementAmendTempExeCycleAndReportDispatchEtcTestReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1238619_1
    }

    /*D3执行修正模板执行周期及汇报调度等测试[7692]   */
    Assert.isNull(implementAmendTempExeCycleAndReportDispatchEtcTestReqDto.getEvaObjEntityId(),"B3执行修正模板执行周期及汇报调度等测试(管理)-D3执行修正模板执行周期及汇报调度等测试-被评对象内容表主键ID不能为空",false);
Assert.isNull(implementAmendTempExeCycleAndReportDispatchEtcTestReqDto.getEvaObjTypeCode(),"B3执行修正模板执行周期及汇报调度等测试(管理)-D3执行修正模板执行周期及汇报调度等测试-被评对象类型编码不能为空",false);
Assert.isNull(implementAmendTempExeCycleAndReportDispatchEtcTestReqDto.getEvaluationTemplateId(),"B3执行修正模板执行周期及汇报调度等测试(管理)-D3执行修正模板执行周期及汇报调度等测试-冗余评价模板ID不能为空",false);
Assert.isNull(implementAmendTempExeCycleAndReportDispatchEtcTestReqDto.getSpaceId(),"B3执行修正模板执行周期及汇报调度等测试(管理)-D3执行修正模板执行周期及汇报调度等测试-创建于空间ID不能为空",false);
      implementAmendTempExeCycleAndReportDispatchEtcTestRespDto = fwAppSystemTestDomainClient.implementAmendTempExeCycleAndReportDispatchEtcTest(implementAmendTempExeCycleAndReportDispatchEtcTestReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




BffImplementAmendTempExeCycleAndReportDispatchEtcTestRespDto retData = new BffImplementAmendTempExeCycleAndReportDispatchEtcTestRespDto();





return retData;
  }
 //
}
